|
|
@@ -1,5254 +0,0 @@
|
|
|
-var Module = (function () {
|
|
|
- var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
|
|
|
- return function (Module) {
|
|
|
- Module = Module || {};
|
|
|
- var Module = typeof Module !== 'undefined' ? Module : {};
|
|
|
- var readyPromiseResolve, readyPromiseReject;
|
|
|
- Module['ready'] = new Promise(function (resolve, reject) {
|
|
|
- readyPromiseResolve = resolve;
|
|
|
- readyPromiseReject = reject;
|
|
|
- });
|
|
|
- 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 = true;
|
|
|
- var ENVIRONMENT_IS_WORKER = false;
|
|
|
- var scriptDirectory = '';
|
|
|
- function locateFile(path) {
|
|
|
- if (Module['locateFile']) {
|
|
|
- return Module['locateFile'](path, scriptDirectory);
|
|
|
- }
|
|
|
- return scriptDirectory + path;
|
|
|
- }
|
|
|
- var read_, readAsync, readBinary, setWindowTitle;
|
|
|
- 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 (_scriptDir) {
|
|
|
- scriptDirectory = _scriptDir;
|
|
|
- }
|
|
|
- if (scriptDirectory.indexOf('blob:') !== 0) {
|
|
|
- scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, '').lastIndexOf('/') + 1);
|
|
|
- } else {
|
|
|
- scriptDirectory = '';
|
|
|
- }
|
|
|
- {
|
|
|
- read_ = function (url) {
|
|
|
- var xhr = new XMLHttpRequest();
|
|
|
- xhr.open('GET', url, false);
|
|
|
- xhr.send(null);
|
|
|
- return xhr.responseText;
|
|
|
- };
|
|
|
- if (ENVIRONMENT_IS_WORKER) {
|
|
|
- readBinary = function (url) {
|
|
|
- var xhr = new XMLHttpRequest();
|
|
|
- xhr.open('GET', url, false);
|
|
|
- xhr.responseType = 'arraybuffer';
|
|
|
- xhr.send(null);
|
|
|
- return new Uint8Array(xhr.response);
|
|
|
- };
|
|
|
- }
|
|
|
- readAsync = function (url, onload, onerror) {
|
|
|
- var xhr = new XMLHttpRequest();
|
|
|
- xhr.open('GET', url, true);
|
|
|
- xhr.responseType = 'arraybuffer';
|
|
|
- xhr.onload = function () {
|
|
|
- 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 {
|
|
|
- }
|
|
|
- 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 (Module['thisProgram']) thisProgram = Module['thisProgram'];
|
|
|
- if (Module['quit']) quit_ = Module['quit'];
|
|
|
- var tempRet0 = 0;
|
|
|
- var setTempRet0 = function (value) {
|
|
|
- tempRet0 = value;
|
|
|
- };
|
|
|
- var wasmBinary;
|
|
|
- if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];
|
|
|
- var noExitRuntime = Module['noExitRuntime'] || true;
|
|
|
- if (typeof WebAssembly !== 'object') {
|
|
|
- abort('no native wasm support detected');
|
|
|
- }
|
|
|
- var wasmMemory;
|
|
|
- var ABORT = false;
|
|
|
- var EXITSTATUS;
|
|
|
- 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;
|
|
|
- if (args) {
|
|
|
- for (var i = 0; i < args.length; i++) {
|
|
|
- var converter = toC[argTypes[i]];
|
|
|
- if (converter) {
|
|
|
- if (stack === 0) stack = stackSave();
|
|
|
- cArgs[i] = converter(args[i]);
|
|
|
- } else {
|
|
|
- cArgs[i] = args[i];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- var ret = func.apply(null, cArgs);
|
|
|
- function onDone(ret) {
|
|
|
- if (stack !== 0) stackRestore(stack);
|
|
|
- return convertReturnValue(ret);
|
|
|
- }
|
|
|
- ret = onDone(ret);
|
|
|
- return ret;
|
|
|
- }
|
|
|
- var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined;
|
|
|
- function UTF8ArrayToString(heap, idx, maxBytesToRead) {
|
|
|
- var endIdx = idx + maxBytesToRead;
|
|
|
- var endPtr = idx;
|
|
|
- while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr;
|
|
|
- if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
|
|
|
- return UTF8Decoder.decode(heap.subarray(idx, endPtr));
|
|
|
- } else {
|
|
|
- var str = '';
|
|
|
- while (idx < endPtr) {
|
|
|
- var u0 = heap[idx++];
|
|
|
- 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 {
|
|
|
- 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;
|
|
|
- heap[outIdx++] = 240 | (u >> 18);
|
|
|
- heap[outIdx++] = 128 | ((u >> 12) & 63);
|
|
|
- heap[outIdx++] = 128 | ((u >> 6) & 63);
|
|
|
- heap[outIdx++] = 128 | (u & 63);
|
|
|
- }
|
|
|
- }
|
|
|
- heap[outIdx] = 0;
|
|
|
- return outIdx - startIdx;
|
|
|
- }
|
|
|
- function stringToUTF8(str, outPtr, maxBytesToWrite) {
|
|
|
- return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
|
|
|
- }
|
|
|
- function 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;
|
|
|
- }
|
|
|
- var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined;
|
|
|
- function UTF16ToString(ptr, maxBytesToRead) {
|
|
|
- var endPtr = ptr;
|
|
|
- var idx = endPtr >> 1;
|
|
|
- var maxIdx = idx + maxBytesToRead / 2;
|
|
|
- while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;
|
|
|
- endPtr = idx << 1;
|
|
|
- if (endPtr - ptr > 32 && UTF16Decoder) {
|
|
|
- return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
|
|
|
- } else {
|
|
|
- var str = '';
|
|
|
- for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
|
|
|
- var codeUnit = HEAP16[(ptr + i * 2) >> 1];
|
|
|
- if (codeUnit == 0) break;
|
|
|
- str += String.fromCharCode(codeUnit);
|
|
|
- }
|
|
|
- return str;
|
|
|
- }
|
|
|
- }
|
|
|
- function stringToUTF16(str, outPtr, maxBytesToWrite) {
|
|
|
- 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);
|
|
|
- HEAP16[outPtr >> 1] = codeUnit;
|
|
|
- outPtr += 2;
|
|
|
- }
|
|
|
- HEAP16[outPtr >> 1] = 0;
|
|
|
- return outPtr - startPtr;
|
|
|
- }
|
|
|
- function lengthBytesUTF16(str) {
|
|
|
- return str.length * 2;
|
|
|
- }
|
|
|
- function UTF32ToString(ptr, maxBytesToRead) {
|
|
|
- var i = 0;
|
|
|
- var str = '';
|
|
|
- while (!(i >= maxBytesToRead / 4)) {
|
|
|
- var utf32 = HEAP32[(ptr + i * 4) >> 2];
|
|
|
- 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) {
|
|
|
- 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);
|
|
|
- }
|
|
|
- HEAP32[outPtr >> 2] = codeUnit;
|
|
|
- outPtr += 4;
|
|
|
- if (outPtr + 4 > endPtr) break;
|
|
|
- }
|
|
|
- HEAP32[outPtr >> 2] = 0;
|
|
|
- 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 writeArrayToMemory(array, buffer) {
|
|
|
- HEAP8.set(array, buffer);
|
|
|
- }
|
|
|
- function writeAsciiToMemory(str, buffer, dontAddNull) {
|
|
|
- for (var i = 0; i < str.length; ++i) {
|
|
|
- HEAP8[buffer++ >> 0] = str.charCodeAt(i);
|
|
|
- }
|
|
|
- if (!dontAddNull) HEAP8[buffer >> 0] = 0;
|
|
|
- }
|
|
|
- function alignUp(x, multiple) {
|
|
|
- if (x % multiple > 0) {
|
|
|
- x += multiple - (x % multiple);
|
|
|
- }
|
|
|
- return x;
|
|
|
- }
|
|
|
- var 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 INITIAL_MEMORY = Module['INITIAL_MEMORY'] || 16777216;
|
|
|
- var wasmTable;
|
|
|
- var __ATPRERUN__ = [];
|
|
|
- var __ATINIT__ = [];
|
|
|
- var __ATPOSTRUN__ = [];
|
|
|
- var runtimeInitialized = false;
|
|
|
- function preRun() {
|
|
|
- if (Module['preRun']) {
|
|
|
- if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
|
|
|
- while (Module['preRun'].length) {
|
|
|
- addOnPreRun(Module['preRun'].shift());
|
|
|
- }
|
|
|
- }
|
|
|
- callRuntimeCallbacks(__ATPRERUN__);
|
|
|
- }
|
|
|
- function initRuntime() {
|
|
|
- runtimeInitialized = true;
|
|
|
- if (!Module['noFSInit'] && !FS.init.initialized) FS.init();
|
|
|
- FS.ignorePermissions = false;
|
|
|
- TTY.init();
|
|
|
- callRuntimeCallbacks(__ATINIT__);
|
|
|
- }
|
|
|
- function postRun() {
|
|
|
- if (Module['postRun']) {
|
|
|
- if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
|
|
|
- while (Module['postRun'].length) {
|
|
|
- addOnPostRun(Module['postRun'].shift());
|
|
|
- }
|
|
|
- }
|
|
|
- callRuntimeCallbacks(__ATPOSTRUN__);
|
|
|
- }
|
|
|
- function addOnPreRun(cb) {
|
|
|
- __ATPRERUN__.unshift(cb);
|
|
|
- }
|
|
|
- function addOnInit(cb) {
|
|
|
- __ATINIT__.unshift(cb);
|
|
|
- }
|
|
|
- function addOnPostRun(cb) {
|
|
|
- __ATPOSTRUN__.unshift(cb);
|
|
|
- }
|
|
|
- var runDependencies = 0;
|
|
|
- var runDependencyWatcher = null;
|
|
|
- var dependenciesFulfilled = null;
|
|
|
- function getUniqueRunDependency(id) {
|
|
|
- return id;
|
|
|
- }
|
|
|
- function addRunDependency(id) {
|
|
|
- runDependencies++;
|
|
|
- if (Module['monitorRunDependencies']) {
|
|
|
- Module['monitorRunDependencies'](runDependencies);
|
|
|
- }
|
|
|
- }
|
|
|
- function removeRunDependency(id) {
|
|
|
- runDependencies--;
|
|
|
- if (Module['monitorRunDependencies']) {
|
|
|
- Module['monitorRunDependencies'](runDependencies);
|
|
|
- }
|
|
|
- if (runDependencies == 0) {
|
|
|
- if (runDependencyWatcher !== null) {
|
|
|
- clearInterval(runDependencyWatcher);
|
|
|
- runDependencyWatcher = null;
|
|
|
- }
|
|
|
- if (dependenciesFulfilled) {
|
|
|
- var callback = dependenciesFulfilled;
|
|
|
- dependenciesFulfilled = null;
|
|
|
- callback();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- Module['preloadedImages'] = {};
|
|
|
- Module['preloadedAudios'] = {};
|
|
|
- function abort(what) {
|
|
|
- {
|
|
|
- if (Module['onAbort']) {
|
|
|
- Module['onAbort'](what);
|
|
|
- }
|
|
|
- }
|
|
|
- what = 'Aborted(' + what + ')';
|
|
|
- err(what);
|
|
|
- ABORT = true;
|
|
|
- EXITSTATUS = 1;
|
|
|
- what += '. Build with -s ASSERTIONS=1 for more info.';
|
|
|
- var e = new WebAssembly.RuntimeError(what);
|
|
|
- readyPromiseReject(e);
|
|
|
- throw e;
|
|
|
- }
|
|
|
- var dataURIPrefix = 'data:application/octet-stream;base64,';
|
|
|
- function isDataURI(filename) {
|
|
|
- return filename.startsWith(dataURIPrefix);
|
|
|
- }
|
|
|
- var wasmBinaryFile;
|
|
|
- wasmBinaryFile = 'process.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)) {
|
|
|
- if (typeof fetch === 'function') {
|
|
|
- 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 = { a: asmLibraryArg };
|
|
|
- function receiveInstance(instance, module) {
|
|
|
- var exports = instance.exports;
|
|
|
- Module['asm'] = exports;
|
|
|
- wasmMemory = Module['asm']['M'];
|
|
|
- updateGlobalBufferAndViews(wasmMemory.buffer);
|
|
|
- wasmTable = Module['asm']['O'];
|
|
|
- addOnInit(Module['asm']['N']);
|
|
|
- removeRunDependency('wasm-instantiate');
|
|
|
- }
|
|
|
- addRunDependency('wasm-instantiate');
|
|
|
- function receiveInstantiationResult(result) {
|
|
|
- receiveInstance(result['instance']);
|
|
|
- }
|
|
|
- function instantiateArrayBuffer(receiver) {
|
|
|
- return getBinaryPromise()
|
|
|
- .then(function (binary) {
|
|
|
- return WebAssembly.instantiate(binary, info);
|
|
|
- })
|
|
|
- .then(function (instance) {
|
|
|
- return instance;
|
|
|
- })
|
|
|
- .then(receiver, function (reason) {
|
|
|
- err('failed to asynchronously prepare wasm: ' + reason);
|
|
|
- abort(reason);
|
|
|
- });
|
|
|
- }
|
|
|
- function instantiateAsync() {
|
|
|
- if (
|
|
|
- !wasmBinary &&
|
|
|
- typeof WebAssembly.instantiateStreaming === 'function' &&
|
|
|
- !isDataURI(wasmBinaryFile) &&
|
|
|
- typeof fetch === 'function'
|
|
|
- ) {
|
|
|
- return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function (response) {
|
|
|
- var result = WebAssembly.instantiateStreaming(response, info);
|
|
|
- return result.then(receiveInstantiationResult, function (reason) {
|
|
|
- err('wasm streaming compile failed: ' + reason);
|
|
|
- err('falling back to ArrayBuffer instantiation');
|
|
|
- return instantiateArrayBuffer(receiveInstantiationResult);
|
|
|
- });
|
|
|
- });
|
|
|
- } else {
|
|
|
- return instantiateArrayBuffer(receiveInstantiationResult);
|
|
|
- }
|
|
|
- }
|
|
|
- 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().catch(readyPromiseReject);
|
|
|
- return {};
|
|
|
- }
|
|
|
- var tempDouble;
|
|
|
- var tempI64;
|
|
|
- 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) {
|
|
|
- getWasmTableEntry(func)();
|
|
|
- } else {
|
|
|
- getWasmTableEntry(func)(callback.arg);
|
|
|
- }
|
|
|
- } else {
|
|
|
- func(callback.arg === undefined ? null : callback.arg);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- var wasmTableMirror = [];
|
|
|
- function getWasmTableEntry(funcPtr) {
|
|
|
- var func = wasmTableMirror[funcPtr];
|
|
|
- if (!func) {
|
|
|
- if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
|
|
|
- wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
|
|
|
- }
|
|
|
- return func;
|
|
|
- }
|
|
|
- function ___cxa_allocate_exception(size) {
|
|
|
- return _malloc(size + 16) + 16;
|
|
|
- }
|
|
|
- function ExceptionInfo(excPtr) {
|
|
|
- this.excPtr = excPtr;
|
|
|
- this.ptr = excPtr - 16;
|
|
|
- this.set_type = function (type) {
|
|
|
- HEAP32[(this.ptr + 4) >> 2] = type;
|
|
|
- };
|
|
|
- this.get_type = function () {
|
|
|
- return HEAP32[(this.ptr + 4) >> 2];
|
|
|
- };
|
|
|
- this.set_destructor = function (destructor) {
|
|
|
- HEAP32[(this.ptr + 8) >> 2] = destructor;
|
|
|
- };
|
|
|
- this.get_destructor = function () {
|
|
|
- return HEAP32[(this.ptr + 8) >> 2];
|
|
|
- };
|
|
|
- this.set_refcount = function (refcount) {
|
|
|
- HEAP32[this.ptr >> 2] = refcount;
|
|
|
- };
|
|
|
- this.set_caught = function (caught) {
|
|
|
- caught = caught ? 1 : 0;
|
|
|
- HEAP8[(this.ptr + 12) >> 0] = caught;
|
|
|
- };
|
|
|
- this.get_caught = function () {
|
|
|
- return HEAP8[(this.ptr + 12) >> 0] != 0;
|
|
|
- };
|
|
|
- this.set_rethrown = function (rethrown) {
|
|
|
- rethrown = rethrown ? 1 : 0;
|
|
|
- HEAP8[(this.ptr + 13) >> 0] = rethrown;
|
|
|
- };
|
|
|
- this.get_rethrown = function () {
|
|
|
- return HEAP8[(this.ptr + 13) >> 0] != 0;
|
|
|
- };
|
|
|
- this.init = function (type, destructor) {
|
|
|
- this.set_type(type);
|
|
|
- this.set_destructor(destructor);
|
|
|
- this.set_refcount(0);
|
|
|
- this.set_caught(false);
|
|
|
- this.set_rethrown(false);
|
|
|
- };
|
|
|
- this.add_ref = function () {
|
|
|
- var value = HEAP32[this.ptr >> 2];
|
|
|
- HEAP32[this.ptr >> 2] = value + 1;
|
|
|
- };
|
|
|
- this.release_ref = function () {
|
|
|
- var prev = HEAP32[this.ptr >> 2];
|
|
|
- HEAP32[this.ptr >> 2] = prev - 1;
|
|
|
- return prev === 1;
|
|
|
- };
|
|
|
- }
|
|
|
- var exceptionLast = 0;
|
|
|
- var uncaughtExceptionCount = 0;
|
|
|
- function ___cxa_throw(ptr, type, destructor) {
|
|
|
- var info = new ExceptionInfo(ptr);
|
|
|
- info.init(type, destructor);
|
|
|
- exceptionLast = ptr;
|
|
|
- uncaughtExceptionCount++;
|
|
|
- throw ptr;
|
|
|
- }
|
|
|
- var tupleRegistrations = {};
|
|
|
- function runDestructors(destructors) {
|
|
|
- while (destructors.length) {
|
|
|
- var ptr = destructors.pop();
|
|
|
- var del = destructors.pop();
|
|
|
- del(ptr);
|
|
|
- }
|
|
|
- }
|
|
|
- function simpleReadValueFromPointer(pointer) {
|
|
|
- return this['fromWireType'](HEAPU32[pointer >> 2]);
|
|
|
- }
|
|
|
- var awaitingDependencies = {};
|
|
|
- var registeredTypes = {};
|
|
|
- var typeDependencies = {};
|
|
|
- var char_0 = 48;
|
|
|
- var char_9 = 57;
|
|
|
- function makeLegalFunctionName(name) {
|
|
|
- if (undefined === name) {
|
|
|
- return '_unknown';
|
|
|
- }
|
|
|
- name = name.replace(/[^a-zA-Z0-9_]/g, '$');
|
|
|
- var f = name.charCodeAt(0);
|
|
|
- if (f >= char_0 && f <= char_9) {
|
|
|
- return '_' + name;
|
|
|
- } else {
|
|
|
- return name;
|
|
|
- }
|
|
|
- }
|
|
|
- function createNamedFunction(name, body) {
|
|
|
- name = makeLegalFunctionName(name);
|
|
|
- return new Function('body', 'return function ' + name + '() {\n "use strict"; return body.apply(this, arguments);\n};\n')(body);
|
|
|
- }
|
|
|
- function extendError(baseErrorType, errorName) {
|
|
|
- var errorClass = createNamedFunction(errorName, function (message) {
|
|
|
- this.name = errorName;
|
|
|
- this.message = message;
|
|
|
- var stack = new Error(message).stack;
|
|
|
- if (stack !== undefined) {
|
|
|
- this.stack = this.toString() + '\n' + stack.replace(/^Error(:[^\n]*)?\n/, '');
|
|
|
- }
|
|
|
- });
|
|
|
- errorClass.prototype = Object.create(baseErrorType.prototype);
|
|
|
- errorClass.prototype.constructor = errorClass;
|
|
|
- errorClass.prototype.toString = function () {
|
|
|
- if (this.message === undefined) {
|
|
|
- return this.name;
|
|
|
- } else {
|
|
|
- return this.name + ': ' + this.message;
|
|
|
- }
|
|
|
- };
|
|
|
- return errorClass;
|
|
|
- }
|
|
|
- var InternalError = undefined;
|
|
|
- function throwInternalError(message) {
|
|
|
- throw new InternalError(message);
|
|
|
- }
|
|
|
- function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) {
|
|
|
- myTypes.forEach(function (type) {
|
|
|
- typeDependencies[type] = dependentTypes;
|
|
|
- });
|
|
|
- function onComplete(typeConverters) {
|
|
|
- var myTypeConverters = getTypeConverters(typeConverters);
|
|
|
- if (myTypeConverters.length !== myTypes.length) {
|
|
|
- throwInternalError('Mismatched type converter count');
|
|
|
- }
|
|
|
- for (var i = 0; i < myTypes.length; ++i) {
|
|
|
- registerType(myTypes[i], myTypeConverters[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- var typeConverters = new Array(dependentTypes.length);
|
|
|
- var unregisteredTypes = [];
|
|
|
- var registered = 0;
|
|
|
- dependentTypes.forEach(function (dt, i) {
|
|
|
- if (registeredTypes.hasOwnProperty(dt)) {
|
|
|
- typeConverters[i] = registeredTypes[dt];
|
|
|
- } else {
|
|
|
- unregisteredTypes.push(dt);
|
|
|
- if (!awaitingDependencies.hasOwnProperty(dt)) {
|
|
|
- awaitingDependencies[dt] = [];
|
|
|
- }
|
|
|
- awaitingDependencies[dt].push(function () {
|
|
|
- typeConverters[i] = registeredTypes[dt];
|
|
|
- ++registered;
|
|
|
- if (registered === unregisteredTypes.length) {
|
|
|
- onComplete(typeConverters);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- });
|
|
|
- if (0 === unregisteredTypes.length) {
|
|
|
- onComplete(typeConverters);
|
|
|
- }
|
|
|
- }
|
|
|
- function __embind_finalize_value_array(rawTupleType) {
|
|
|
- var reg = tupleRegistrations[rawTupleType];
|
|
|
- delete tupleRegistrations[rawTupleType];
|
|
|
- var elements = reg.elements;
|
|
|
- var elementsLength = elements.length;
|
|
|
- var elementTypes = elements
|
|
|
- .map(function (elt) {
|
|
|
- return elt.getterReturnType;
|
|
|
- })
|
|
|
- .concat(
|
|
|
- elements.map(function (elt) {
|
|
|
- return elt.setterArgumentType;
|
|
|
- })
|
|
|
- );
|
|
|
- var rawConstructor = reg.rawConstructor;
|
|
|
- var rawDestructor = reg.rawDestructor;
|
|
|
- whenDependentTypesAreResolved([rawTupleType], elementTypes, function (elementTypes) {
|
|
|
- elements.forEach(function (elt, i) {
|
|
|
- var getterReturnType = elementTypes[i];
|
|
|
- var getter = elt.getter;
|
|
|
- var getterContext = elt.getterContext;
|
|
|
- var setterArgumentType = elementTypes[i + elementsLength];
|
|
|
- var setter = elt.setter;
|
|
|
- var setterContext = elt.setterContext;
|
|
|
- elt.read = function (ptr) {
|
|
|
- return getterReturnType['fromWireType'](getter(getterContext, ptr));
|
|
|
- };
|
|
|
- elt.write = function (ptr, o) {
|
|
|
- var destructors = [];
|
|
|
- setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, o));
|
|
|
- runDestructors(destructors);
|
|
|
- };
|
|
|
- });
|
|
|
- return [
|
|
|
- {
|
|
|
- name: reg.name,
|
|
|
- fromWireType: function (ptr) {
|
|
|
- var rv = new Array(elementsLength);
|
|
|
- for (var i = 0; i < elementsLength; ++i) {
|
|
|
- rv[i] = elements[i].read(ptr);
|
|
|
- }
|
|
|
- rawDestructor(ptr);
|
|
|
- return rv;
|
|
|
- },
|
|
|
- toWireType: function (destructors, o) {
|
|
|
- if (elementsLength !== o.length) {
|
|
|
- throw new TypeError(
|
|
|
- 'Incorrect number of tuple elements for ' + reg.name + ': expected=' + elementsLength + ', actual=' + o.length
|
|
|
- );
|
|
|
- }
|
|
|
- var ptr = rawConstructor();
|
|
|
- for (var i = 0; i < elementsLength; ++i) {
|
|
|
- elements[i].write(ptr, o[i]);
|
|
|
- }
|
|
|
- if (destructors !== null) {
|
|
|
- destructors.push(rawDestructor, ptr);
|
|
|
- }
|
|
|
- return ptr;
|
|
|
- },
|
|
|
- argPackAdvance: 8,
|
|
|
- readValueFromPointer: simpleReadValueFromPointer,
|
|
|
- destructorFunction: rawDestructor
|
|
|
- }
|
|
|
- ];
|
|
|
- });
|
|
|
- }
|
|
|
- var structRegistrations = {};
|
|
|
- function __embind_finalize_value_object(structType) {
|
|
|
- var reg = structRegistrations[structType];
|
|
|
- delete structRegistrations[structType];
|
|
|
- var rawConstructor = reg.rawConstructor;
|
|
|
- var rawDestructor = reg.rawDestructor;
|
|
|
- var fieldRecords = reg.fields;
|
|
|
- var fieldTypes = fieldRecords
|
|
|
- .map(function (field) {
|
|
|
- return field.getterReturnType;
|
|
|
- })
|
|
|
- .concat(
|
|
|
- fieldRecords.map(function (field) {
|
|
|
- return field.setterArgumentType;
|
|
|
- })
|
|
|
- );
|
|
|
- whenDependentTypesAreResolved([structType], fieldTypes, function (fieldTypes) {
|
|
|
- var fields = {};
|
|
|
- fieldRecords.forEach(function (field, i) {
|
|
|
- var fieldName = field.fieldName;
|
|
|
- var getterReturnType = fieldTypes[i];
|
|
|
- var getter = field.getter;
|
|
|
- var getterContext = field.getterContext;
|
|
|
- var setterArgumentType = fieldTypes[i + fieldRecords.length];
|
|
|
- var setter = field.setter;
|
|
|
- var setterContext = field.setterContext;
|
|
|
- fields[fieldName] = {
|
|
|
- read: function (ptr) {
|
|
|
- return getterReturnType['fromWireType'](getter(getterContext, ptr));
|
|
|
- },
|
|
|
- write: function (ptr, o) {
|
|
|
- var destructors = [];
|
|
|
- setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, o));
|
|
|
- runDestructors(destructors);
|
|
|
- }
|
|
|
- };
|
|
|
- });
|
|
|
- return [
|
|
|
- {
|
|
|
- name: reg.name,
|
|
|
- fromWireType: function (ptr) {
|
|
|
- var rv = {};
|
|
|
- for (var i in fields) {
|
|
|
- rv[i] = fields[i].read(ptr);
|
|
|
- }
|
|
|
- rawDestructor(ptr);
|
|
|
- return rv;
|
|
|
- },
|
|
|
- toWireType: function (destructors, o) {
|
|
|
- for (var fieldName in fields) {
|
|
|
- if (!(fieldName in o)) {
|
|
|
- throw new TypeError('Missing field: "' + fieldName + '"');
|
|
|
- }
|
|
|
- }
|
|
|
- var ptr = rawConstructor();
|
|
|
- for (fieldName in fields) {
|
|
|
- fields[fieldName].write(ptr, o[fieldName]);
|
|
|
- }
|
|
|
- if (destructors !== null) {
|
|
|
- destructors.push(rawDestructor, ptr);
|
|
|
- }
|
|
|
- return ptr;
|
|
|
- },
|
|
|
- argPackAdvance: 8,
|
|
|
- readValueFromPointer: simpleReadValueFromPointer,
|
|
|
- destructorFunction: rawDestructor
|
|
|
- }
|
|
|
- ];
|
|
|
- });
|
|
|
- }
|
|
|
- function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {}
|
|
|
- function getShiftFromSize(size) {
|
|
|
- switch (size) {
|
|
|
- case 1:
|
|
|
- return 0;
|
|
|
- case 2:
|
|
|
- return 1;
|
|
|
- case 4:
|
|
|
- return 2;
|
|
|
- case 8:
|
|
|
- return 3;
|
|
|
- default:
|
|
|
- throw new TypeError('Unknown type size: ' + size);
|
|
|
- }
|
|
|
- }
|
|
|
- function embind_init_charCodes() {
|
|
|
- var codes = new Array(256);
|
|
|
- for (var i = 0; i < 256; ++i) {
|
|
|
- codes[i] = String.fromCharCode(i);
|
|
|
- }
|
|
|
- embind_charCodes = codes;
|
|
|
- }
|
|
|
- var embind_charCodes = undefined;
|
|
|
- function readLatin1String(ptr) {
|
|
|
- var ret = '';
|
|
|
- var c = ptr;
|
|
|
- while (HEAPU8[c]) {
|
|
|
- ret += embind_charCodes[HEAPU8[c++]];
|
|
|
- }
|
|
|
- return ret;
|
|
|
- }
|
|
|
- var BindingError = undefined;
|
|
|
- function throwBindingError(message) {
|
|
|
- throw new BindingError(message);
|
|
|
- }
|
|
|
- function registerType(rawType, registeredInstance, options) {
|
|
|
- options = options || {};
|
|
|
- if (!('argPackAdvance' in registeredInstance)) {
|
|
|
- throw new TypeError('registerType registeredInstance requires argPackAdvance');
|
|
|
- }
|
|
|
- var name = registeredInstance.name;
|
|
|
- if (!rawType) {
|
|
|
- throwBindingError('type "' + name + '" must have a positive integer typeid pointer');
|
|
|
- }
|
|
|
- if (registeredTypes.hasOwnProperty(rawType)) {
|
|
|
- if (options.ignoreDuplicateRegistrations) {
|
|
|
- return;
|
|
|
- } else {
|
|
|
- throwBindingError("Cannot register type '" + name + "' twice");
|
|
|
- }
|
|
|
- }
|
|
|
- registeredTypes[rawType] = registeredInstance;
|
|
|
- delete typeDependencies[rawType];
|
|
|
- if (awaitingDependencies.hasOwnProperty(rawType)) {
|
|
|
- var callbacks = awaitingDependencies[rawType];
|
|
|
- delete awaitingDependencies[rawType];
|
|
|
- callbacks.forEach(function (cb) {
|
|
|
- cb();
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- function __embind_register_bool(rawType, name, size, trueValue, falseValue) {
|
|
|
- var shift = getShiftFromSize(size);
|
|
|
- name = readLatin1String(name);
|
|
|
- registerType(rawType, {
|
|
|
- name: name,
|
|
|
- fromWireType: function (wt) {
|
|
|
- return !!wt;
|
|
|
- },
|
|
|
- toWireType: function (destructors, o) {
|
|
|
- return o ? trueValue : falseValue;
|
|
|
- },
|
|
|
- argPackAdvance: 8,
|
|
|
- readValueFromPointer: function (pointer) {
|
|
|
- var heap;
|
|
|
- if (size === 1) {
|
|
|
- heap = HEAP8;
|
|
|
- } else if (size === 2) {
|
|
|
- heap = HEAP16;
|
|
|
- } else if (size === 4) {
|
|
|
- heap = HEAP32;
|
|
|
- } else {
|
|
|
- throw new TypeError('Unknown boolean type size: ' + name);
|
|
|
- }
|
|
|
- return this['fromWireType'](heap[pointer >> shift]);
|
|
|
- },
|
|
|
- destructorFunction: null
|
|
|
- });
|
|
|
- }
|
|
|
- function ClassHandle_isAliasOf(other) {
|
|
|
- if (!(this instanceof ClassHandle)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (!(other instanceof ClassHandle)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- var leftClass = this.$$.ptrType.registeredClass;
|
|
|
- var left = this.$$.ptr;
|
|
|
- var rightClass = other.$$.ptrType.registeredClass;
|
|
|
- var right = other.$$.ptr;
|
|
|
- while (leftClass.baseClass) {
|
|
|
- left = leftClass.upcast(left);
|
|
|
- leftClass = leftClass.baseClass;
|
|
|
- }
|
|
|
- while (rightClass.baseClass) {
|
|
|
- right = rightClass.upcast(right);
|
|
|
- rightClass = rightClass.baseClass;
|
|
|
- }
|
|
|
- return leftClass === rightClass && left === right;
|
|
|
- }
|
|
|
- function shallowCopyInternalPointer(o) {
|
|
|
- return {
|
|
|
- count: o.count,
|
|
|
- deleteScheduled: o.deleteScheduled,
|
|
|
- preservePointerOnDelete: o.preservePointerOnDelete,
|
|
|
- ptr: o.ptr,
|
|
|
- ptrType: o.ptrType,
|
|
|
- smartPtr: o.smartPtr,
|
|
|
- smartPtrType: o.smartPtrType
|
|
|
- };
|
|
|
- }
|
|
|
- function throwInstanceAlreadyDeleted(obj) {
|
|
|
- function getInstanceTypeName(handle) {
|
|
|
- return handle.$$.ptrType.registeredClass.name;
|
|
|
- }
|
|
|
- throwBindingError(getInstanceTypeName(obj) + ' instance already deleted');
|
|
|
- }
|
|
|
- var finalizationRegistry = false;
|
|
|
- function detachFinalizer(handle) {}
|
|
|
- function runDestructor($$) {
|
|
|
- if ($$.smartPtr) {
|
|
|
- $$.smartPtrType.rawDestructor($$.smartPtr);
|
|
|
- } else {
|
|
|
- $$.ptrType.registeredClass.rawDestructor($$.ptr);
|
|
|
- }
|
|
|
- }
|
|
|
- function releaseClassHandle($$) {
|
|
|
- $$.count.value -= 1;
|
|
|
- var toDelete = 0 === $$.count.value;
|
|
|
- if (toDelete) {
|
|
|
- runDestructor($$);
|
|
|
- }
|
|
|
- }
|
|
|
- function attachFinalizer(handle) {
|
|
|
- if ('undefined' === typeof FinalizationRegistry) {
|
|
|
- attachFinalizer = function (handle) {
|
|
|
- return handle;
|
|
|
- };
|
|
|
- return handle;
|
|
|
- }
|
|
|
- finalizationRegistry = new FinalizationRegistry(function (info) {
|
|
|
- releaseClassHandle(info.$$);
|
|
|
- });
|
|
|
- attachFinalizer = function (handle) {
|
|
|
- var $$ = handle.$$;
|
|
|
- var info = { $$: $$ };
|
|
|
- finalizationRegistry.register(handle, info, handle);
|
|
|
- return handle;
|
|
|
- };
|
|
|
- detachFinalizer = function (handle) {
|
|
|
- finalizationRegistry.unregister(handle);
|
|
|
- };
|
|
|
- return attachFinalizer(handle);
|
|
|
- }
|
|
|
- function ClassHandle_clone() {
|
|
|
- if (!this.$$.ptr) {
|
|
|
- throwInstanceAlreadyDeleted(this);
|
|
|
- }
|
|
|
- if (this.$$.preservePointerOnDelete) {
|
|
|
- this.$$.count.value += 1;
|
|
|
- return this;
|
|
|
- } else {
|
|
|
- var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), { $$: { value: shallowCopyInternalPointer(this.$$) } }));
|
|
|
- clone.$$.count.value += 1;
|
|
|
- clone.$$.deleteScheduled = false;
|
|
|
- return clone;
|
|
|
- }
|
|
|
- }
|
|
|
- function ClassHandle_delete() {
|
|
|
- if (!this.$$.ptr) {
|
|
|
- throwInstanceAlreadyDeleted(this);
|
|
|
- }
|
|
|
- if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
|
|
|
- throwBindingError('Object already scheduled for deletion');
|
|
|
- }
|
|
|
- detachFinalizer(this);
|
|
|
- releaseClassHandle(this.$$);
|
|
|
- if (!this.$$.preservePointerOnDelete) {
|
|
|
- this.$$.smartPtr = undefined;
|
|
|
- this.$$.ptr = undefined;
|
|
|
- }
|
|
|
- }
|
|
|
- function ClassHandle_isDeleted() {
|
|
|
- return !this.$$.ptr;
|
|
|
- }
|
|
|
- var delayFunction = undefined;
|
|
|
- var deletionQueue = [];
|
|
|
- function flushPendingDeletes() {
|
|
|
- while (deletionQueue.length) {
|
|
|
- var obj = deletionQueue.pop();
|
|
|
- obj.$$.deleteScheduled = false;
|
|
|
- obj['delete']();
|
|
|
- }
|
|
|
- }
|
|
|
- function ClassHandle_deleteLater() {
|
|
|
- if (!this.$$.ptr) {
|
|
|
- throwInstanceAlreadyDeleted(this);
|
|
|
- }
|
|
|
- if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
|
|
|
- throwBindingError('Object already scheduled for deletion');
|
|
|
- }
|
|
|
- deletionQueue.push(this);
|
|
|
- if (deletionQueue.length === 1 && delayFunction) {
|
|
|
- delayFunction(flushPendingDeletes);
|
|
|
- }
|
|
|
- this.$$.deleteScheduled = true;
|
|
|
- return this;
|
|
|
- }
|
|
|
- function init_ClassHandle() {
|
|
|
- ClassHandle.prototype['isAliasOf'] = ClassHandle_isAliasOf;
|
|
|
- ClassHandle.prototype['clone'] = ClassHandle_clone;
|
|
|
- ClassHandle.prototype['delete'] = ClassHandle_delete;
|
|
|
- ClassHandle.prototype['isDeleted'] = ClassHandle_isDeleted;
|
|
|
- ClassHandle.prototype['deleteLater'] = ClassHandle_deleteLater;
|
|
|
- }
|
|
|
- function ClassHandle() {}
|
|
|
- var registeredPointers = {};
|
|
|
- function ensureOverloadTable(proto, methodName, humanName) {
|
|
|
- if (undefined === proto[methodName].overloadTable) {
|
|
|
- var prevFunc = proto[methodName];
|
|
|
- proto[methodName] = function () {
|
|
|
- if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
|
|
|
- throwBindingError(
|
|
|
- "Function '" +
|
|
|
- humanName +
|
|
|
- "' called with an invalid number of arguments (" +
|
|
|
- arguments.length +
|
|
|
- ') - expects one of (' +
|
|
|
- proto[methodName].overloadTable +
|
|
|
- ')!'
|
|
|
- );
|
|
|
- }
|
|
|
- return proto[methodName].overloadTable[arguments.length].apply(this, arguments);
|
|
|
- };
|
|
|
- proto[methodName].overloadTable = [];
|
|
|
- proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
|
|
|
- }
|
|
|
- }
|
|
|
- function exposePublicSymbol(name, value, numArguments) {
|
|
|
- if (Module.hasOwnProperty(name)) {
|
|
|
- if (
|
|
|
- undefined === numArguments ||
|
|
|
- (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])
|
|
|
- ) {
|
|
|
- throwBindingError("Cannot register public name '" + name + "' twice");
|
|
|
- }
|
|
|
- ensureOverloadTable(Module, name, name);
|
|
|
- if (Module.hasOwnProperty(numArguments)) {
|
|
|
- throwBindingError('Cannot register multiple overloads of a function with the same number of arguments (' + numArguments + ')!');
|
|
|
- }
|
|
|
- Module[name].overloadTable[numArguments] = value;
|
|
|
- } else {
|
|
|
- Module[name] = value;
|
|
|
- if (undefined !== numArguments) {
|
|
|
- Module[name].numArguments = numArguments;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- function RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) {
|
|
|
- this.name = name;
|
|
|
- this.constructor = constructor;
|
|
|
- this.instancePrototype = instancePrototype;
|
|
|
- this.rawDestructor = rawDestructor;
|
|
|
- this.baseClass = baseClass;
|
|
|
- this.getActualType = getActualType;
|
|
|
- this.upcast = upcast;
|
|
|
- this.downcast = downcast;
|
|
|
- this.pureVirtualFunctions = [];
|
|
|
- }
|
|
|
- function upcastPointer(ptr, ptrClass, desiredClass) {
|
|
|
- while (ptrClass !== desiredClass) {
|
|
|
- if (!ptrClass.upcast) {
|
|
|
- throwBindingError('Expected null or instance of ' + desiredClass.name + ', got an instance of ' + ptrClass.name);
|
|
|
- }
|
|
|
- ptr = ptrClass.upcast(ptr);
|
|
|
- ptrClass = ptrClass.baseClass;
|
|
|
- }
|
|
|
- return ptr;
|
|
|
- }
|
|
|
- function constNoSmartPtrRawPointerToWireType(destructors, handle) {
|
|
|
- if (handle === null) {
|
|
|
- if (this.isReference) {
|
|
|
- throwBindingError('null is not a valid ' + this.name);
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- if (!handle.$$) {
|
|
|
- throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name);
|
|
|
- }
|
|
|
- if (!handle.$$.ptr) {
|
|
|
- throwBindingError('Cannot pass deleted object as a pointer of type ' + this.name);
|
|
|
- }
|
|
|
- var handleClass = handle.$$.ptrType.registeredClass;
|
|
|
- var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
|
|
|
- return ptr;
|
|
|
- }
|
|
|
- function genericPointerToWireType(destructors, handle) {
|
|
|
- var ptr;
|
|
|
- if (handle === null) {
|
|
|
- if (this.isReference) {
|
|
|
- throwBindingError('null is not a valid ' + this.name);
|
|
|
- }
|
|
|
- if (this.isSmartPointer) {
|
|
|
- ptr = this.rawConstructor();
|
|
|
- if (destructors !== null) {
|
|
|
- destructors.push(this.rawDestructor, ptr);
|
|
|
- }
|
|
|
- return ptr;
|
|
|
- } else {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!handle.$$) {
|
|
|
- throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name);
|
|
|
- }
|
|
|
- if (!handle.$$.ptr) {
|
|
|
- throwBindingError('Cannot pass deleted object as a pointer of type ' + this.name);
|
|
|
- }
|
|
|
- if (!this.isConst && handle.$$.ptrType.isConst) {
|
|
|
- throwBindingError(
|
|
|
- 'Cannot convert argument of type ' +
|
|
|
- (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) +
|
|
|
- ' to parameter type ' +
|
|
|
- this.name
|
|
|
- );
|
|
|
- }
|
|
|
- var handleClass = handle.$$.ptrType.registeredClass;
|
|
|
- ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
|
|
|
- if (this.isSmartPointer) {
|
|
|
- if (undefined === handle.$$.smartPtr) {
|
|
|
- throwBindingError('Passing raw pointer to smart pointer is illegal');
|
|
|
- }
|
|
|
- switch (this.sharingPolicy) {
|
|
|
- case 0:
|
|
|
- if (handle.$$.smartPtrType === this) {
|
|
|
- ptr = handle.$$.smartPtr;
|
|
|
- } else {
|
|
|
- throwBindingError(
|
|
|
- 'Cannot convert argument of type ' +
|
|
|
- (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) +
|
|
|
- ' to parameter type ' +
|
|
|
- this.name
|
|
|
- );
|
|
|
- }
|
|
|
- break;
|
|
|
- case 1:
|
|
|
- ptr = handle.$$.smartPtr;
|
|
|
- break;
|
|
|
- case 2:
|
|
|
- if (handle.$$.smartPtrType === this) {
|
|
|
- ptr = handle.$$.smartPtr;
|
|
|
- } else {
|
|
|
- var clonedHandle = handle['clone']();
|
|
|
- ptr = this.rawShare(
|
|
|
- ptr,
|
|
|
- Emval.toHandle(function () {
|
|
|
- clonedHandle['delete']();
|
|
|
- })
|
|
|
- );
|
|
|
- if (destructors !== null) {
|
|
|
- destructors.push(this.rawDestructor, ptr);
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- default:
|
|
|
- throwBindingError('Unsupporting sharing policy');
|
|
|
- }
|
|
|
- }
|
|
|
- return ptr;
|
|
|
- }
|
|
|
- function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {
|
|
|
- if (handle === null) {
|
|
|
- if (this.isReference) {
|
|
|
- throwBindingError('null is not a valid ' + this.name);
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- if (!handle.$$) {
|
|
|
- throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name);
|
|
|
- }
|
|
|
- if (!handle.$$.ptr) {
|
|
|
- throwBindingError('Cannot pass deleted object as a pointer of type ' + this.name);
|
|
|
- }
|
|
|
- if (handle.$$.ptrType.isConst) {
|
|
|
- throwBindingError('Cannot convert argument of type ' + handle.$$.ptrType.name + ' to parameter type ' + this.name);
|
|
|
- }
|
|
|
- var handleClass = handle.$$.ptrType.registeredClass;
|
|
|
- var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
|
|
|
- return ptr;
|
|
|
- }
|
|
|
- function RegisteredPointer_getPointee(ptr) {
|
|
|
- if (this.rawGetPointee) {
|
|
|
- ptr = this.rawGetPointee(ptr);
|
|
|
- }
|
|
|
- return ptr;
|
|
|
- }
|
|
|
- function RegisteredPointer_destructor(ptr) {
|
|
|
- if (this.rawDestructor) {
|
|
|
- this.rawDestructor(ptr);
|
|
|
- }
|
|
|
- }
|
|
|
- function RegisteredPointer_deleteObject(handle) {
|
|
|
- if (handle !== null) {
|
|
|
- handle['delete']();
|
|
|
- }
|
|
|
- }
|
|
|
- function downcastPointer(ptr, ptrClass, desiredClass) {
|
|
|
- if (ptrClass === desiredClass) {
|
|
|
- return ptr;
|
|
|
- }
|
|
|
- if (undefined === desiredClass.baseClass) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass);
|
|
|
- if (rv === null) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return desiredClass.downcast(rv);
|
|
|
- }
|
|
|
- function getInheritedInstanceCount() {
|
|
|
- return Object.keys(registeredInstances).length;
|
|
|
- }
|
|
|
- function getLiveInheritedInstances() {
|
|
|
- var rv = [];
|
|
|
- for (var k in registeredInstances) {
|
|
|
- if (registeredInstances.hasOwnProperty(k)) {
|
|
|
- rv.push(registeredInstances[k]);
|
|
|
- }
|
|
|
- }
|
|
|
- return rv;
|
|
|
- }
|
|
|
- function setDelayFunction(fn) {
|
|
|
- delayFunction = fn;
|
|
|
- if (deletionQueue.length && delayFunction) {
|
|
|
- delayFunction(flushPendingDeletes);
|
|
|
- }
|
|
|
- }
|
|
|
- function init_embind() {
|
|
|
- Module['getInheritedInstanceCount'] = getInheritedInstanceCount;
|
|
|
- Module['getLiveInheritedInstances'] = getLiveInheritedInstances;
|
|
|
- Module['flushPendingDeletes'] = flushPendingDeletes;
|
|
|
- Module['setDelayFunction'] = setDelayFunction;
|
|
|
- }
|
|
|
- var registeredInstances = {};
|
|
|
- function getBasestPointer(class_, ptr) {
|
|
|
- if (ptr === undefined) {
|
|
|
- throwBindingError('ptr should not be undefined');
|
|
|
- }
|
|
|
- while (class_.baseClass) {
|
|
|
- ptr = class_.upcast(ptr);
|
|
|
- class_ = class_.baseClass;
|
|
|
- }
|
|
|
- return ptr;
|
|
|
- }
|
|
|
- function getInheritedInstance(class_, ptr) {
|
|
|
- ptr = getBasestPointer(class_, ptr);
|
|
|
- return registeredInstances[ptr];
|
|
|
- }
|
|
|
- function makeClassHandle(prototype, record) {
|
|
|
- if (!record.ptrType || !record.ptr) {
|
|
|
- throwInternalError('makeClassHandle requires ptr and ptrType');
|
|
|
- }
|
|
|
- var hasSmartPtrType = !!record.smartPtrType;
|
|
|
- var hasSmartPtr = !!record.smartPtr;
|
|
|
- if (hasSmartPtrType !== hasSmartPtr) {
|
|
|
- throwInternalError('Both smartPtrType and smartPtr must be specified');
|
|
|
- }
|
|
|
- record.count = { value: 1 };
|
|
|
- return attachFinalizer(Object.create(prototype, { $$: { value: record } }));
|
|
|
- }
|
|
|
- function RegisteredPointer_fromWireType(ptr) {
|
|
|
- var rawPointer = this.getPointee(ptr);
|
|
|
- if (!rawPointer) {
|
|
|
- this.destructor(ptr);
|
|
|
- return null;
|
|
|
- }
|
|
|
- var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer);
|
|
|
- if (undefined !== registeredInstance) {
|
|
|
- if (0 === registeredInstance.$$.count.value) {
|
|
|
- registeredInstance.$$.ptr = rawPointer;
|
|
|
- registeredInstance.$$.smartPtr = ptr;
|
|
|
- return registeredInstance['clone']();
|
|
|
- } else {
|
|
|
- var rv = registeredInstance['clone']();
|
|
|
- this.destructor(ptr);
|
|
|
- return rv;
|
|
|
- }
|
|
|
- }
|
|
|
- function makeDefaultHandle() {
|
|
|
- if (this.isSmartPointer) {
|
|
|
- return makeClassHandle(this.registeredClass.instancePrototype, {
|
|
|
- ptrType: this.pointeeType,
|
|
|
- ptr: rawPointer,
|
|
|
- smartPtrType: this,
|
|
|
- smartPtr: ptr
|
|
|
- });
|
|
|
- } else {
|
|
|
- return makeClassHandle(this.registeredClass.instancePrototype, { ptrType: this, ptr: ptr });
|
|
|
- }
|
|
|
- }
|
|
|
- var actualType = this.registeredClass.getActualType(rawPointer);
|
|
|
- var registeredPointerRecord = registeredPointers[actualType];
|
|
|
- if (!registeredPointerRecord) {
|
|
|
- return makeDefaultHandle.call(this);
|
|
|
- }
|
|
|
- var toType;
|
|
|
- if (this.isConst) {
|
|
|
- toType = registeredPointerRecord.constPointerType;
|
|
|
- } else {
|
|
|
- toType = registeredPointerRecord.pointerType;
|
|
|
- }
|
|
|
- var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass);
|
|
|
- if (dp === null) {
|
|
|
- return makeDefaultHandle.call(this);
|
|
|
- }
|
|
|
- if (this.isSmartPointer) {
|
|
|
- return makeClassHandle(toType.registeredClass.instancePrototype, { ptrType: toType, ptr: dp, smartPtrType: this, smartPtr: ptr });
|
|
|
- } else {
|
|
|
- return makeClassHandle(toType.registeredClass.instancePrototype, { ptrType: toType, ptr: dp });
|
|
|
- }
|
|
|
- }
|
|
|
- function init_RegisteredPointer() {
|
|
|
- RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee;
|
|
|
- RegisteredPointer.prototype.destructor = RegisteredPointer_destructor;
|
|
|
- RegisteredPointer.prototype['argPackAdvance'] = 8;
|
|
|
- RegisteredPointer.prototype['readValueFromPointer'] = simpleReadValueFromPointer;
|
|
|
- RegisteredPointer.prototype['deleteObject'] = RegisteredPointer_deleteObject;
|
|
|
- RegisteredPointer.prototype['fromWireType'] = RegisteredPointer_fromWireType;
|
|
|
- }
|
|
|
- function RegisteredPointer(
|
|
|
- name,
|
|
|
- registeredClass,
|
|
|
- isReference,
|
|
|
- isConst,
|
|
|
- isSmartPointer,
|
|
|
- pointeeType,
|
|
|
- sharingPolicy,
|
|
|
- rawGetPointee,
|
|
|
- rawConstructor,
|
|
|
- rawShare,
|
|
|
- rawDestructor
|
|
|
- ) {
|
|
|
- this.name = name;
|
|
|
- this.registeredClass = registeredClass;
|
|
|
- this.isReference = isReference;
|
|
|
- this.isConst = isConst;
|
|
|
- this.isSmartPointer = isSmartPointer;
|
|
|
- this.pointeeType = pointeeType;
|
|
|
- this.sharingPolicy = sharingPolicy;
|
|
|
- this.rawGetPointee = rawGetPointee;
|
|
|
- this.rawConstructor = rawConstructor;
|
|
|
- this.rawShare = rawShare;
|
|
|
- this.rawDestructor = rawDestructor;
|
|
|
- if (!isSmartPointer && registeredClass.baseClass === undefined) {
|
|
|
- if (isConst) {
|
|
|
- this['toWireType'] = constNoSmartPtrRawPointerToWireType;
|
|
|
- this.destructorFunction = null;
|
|
|
- } else {
|
|
|
- this['toWireType'] = nonConstNoSmartPtrRawPointerToWireType;
|
|
|
- this.destructorFunction = null;
|
|
|
- }
|
|
|
- } else {
|
|
|
- this['toWireType'] = genericPointerToWireType;
|
|
|
- }
|
|
|
- }
|
|
|
- function replacePublicSymbol(name, value, numArguments) {
|
|
|
- if (!Module.hasOwnProperty(name)) {
|
|
|
- throwInternalError('Replacing nonexistant public symbol');
|
|
|
- }
|
|
|
- if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
|
|
|
- Module[name].overloadTable[numArguments] = value;
|
|
|
- } else {
|
|
|
- Module[name] = value;
|
|
|
- Module[name].argCount = numArguments;
|
|
|
- }
|
|
|
- }
|
|
|
- function dynCallLegacy(sig, ptr, args) {
|
|
|
- var f = Module['dynCall_' + sig];
|
|
|
- return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr);
|
|
|
- }
|
|
|
- function dynCall(sig, ptr, args) {
|
|
|
- if (sig.includes('j')) {
|
|
|
- return dynCallLegacy(sig, ptr, args);
|
|
|
- }
|
|
|
- return getWasmTableEntry(ptr).apply(null, args);
|
|
|
- }
|
|
|
- function getDynCaller(sig, ptr) {
|
|
|
- var argCache = [];
|
|
|
- return function () {
|
|
|
- argCache.length = arguments.length;
|
|
|
- for (var i = 0; i < arguments.length; i++) {
|
|
|
- argCache[i] = arguments[i];
|
|
|
- }
|
|
|
- return dynCall(sig, ptr, argCache);
|
|
|
- };
|
|
|
- }
|
|
|
- function embind__requireFunction(signature, rawFunction) {
|
|
|
- signature = readLatin1String(signature);
|
|
|
- function makeDynCaller() {
|
|
|
- if (signature.includes('j')) {
|
|
|
- return getDynCaller(signature, rawFunction);
|
|
|
- }
|
|
|
- return getWasmTableEntry(rawFunction);
|
|
|
- }
|
|
|
- var fp = makeDynCaller();
|
|
|
- if (typeof fp !== 'function') {
|
|
|
- throwBindingError('unknown function pointer with signature ' + signature + ': ' + rawFunction);
|
|
|
- }
|
|
|
- return fp;
|
|
|
- }
|
|
|
- var UnboundTypeError = undefined;
|
|
|
- function getTypeName(type) {
|
|
|
- var ptr = ___getTypeName(type);
|
|
|
- var rv = readLatin1String(ptr);
|
|
|
- _free(ptr);
|
|
|
- return rv;
|
|
|
- }
|
|
|
- function throwUnboundTypeError(message, types) {
|
|
|
- var unboundTypes = [];
|
|
|
- var seen = {};
|
|
|
- function visit(type) {
|
|
|
- if (seen[type]) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (registeredTypes[type]) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (typeDependencies[type]) {
|
|
|
- typeDependencies[type].forEach(visit);
|
|
|
- return;
|
|
|
- }
|
|
|
- unboundTypes.push(type);
|
|
|
- seen[type] = true;
|
|
|
- }
|
|
|
- types.forEach(visit);
|
|
|
- throw new UnboundTypeError(message + ': ' + unboundTypes.map(getTypeName).join([', ']));
|
|
|
- }
|
|
|
- function __embind_register_class(
|
|
|
- rawType,
|
|
|
- rawPointerType,
|
|
|
- rawConstPointerType,
|
|
|
- baseClassRawType,
|
|
|
- getActualTypeSignature,
|
|
|
- getActualType,
|
|
|
- upcastSignature,
|
|
|
- upcast,
|
|
|
- downcastSignature,
|
|
|
- downcast,
|
|
|
- name,
|
|
|
- destructorSignature,
|
|
|
- rawDestructor
|
|
|
- ) {
|
|
|
- name = readLatin1String(name);
|
|
|
- getActualType = embind__requireFunction(getActualTypeSignature, getActualType);
|
|
|
- if (upcast) {
|
|
|
- upcast = embind__requireFunction(upcastSignature, upcast);
|
|
|
- }
|
|
|
- if (downcast) {
|
|
|
- downcast = embind__requireFunction(downcastSignature, downcast);
|
|
|
- }
|
|
|
- rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
|
|
|
- var legalFunctionName = makeLegalFunctionName(name);
|
|
|
- exposePublicSymbol(legalFunctionName, function () {
|
|
|
- throwUnboundTypeError('Cannot construct ' + name + ' due to unbound types', [baseClassRawType]);
|
|
|
- });
|
|
|
- whenDependentTypesAreResolved(
|
|
|
- [rawType, rawPointerType, rawConstPointerType],
|
|
|
- baseClassRawType ? [baseClassRawType] : [],
|
|
|
- function (base) {
|
|
|
- base = base[0];
|
|
|
- var baseClass;
|
|
|
- var basePrototype;
|
|
|
- if (baseClassRawType) {
|
|
|
- baseClass = base.registeredClass;
|
|
|
- basePrototype = baseClass.instancePrototype;
|
|
|
- } else {
|
|
|
- basePrototype = ClassHandle.prototype;
|
|
|
- }
|
|
|
- var constructor = createNamedFunction(legalFunctionName, function () {
|
|
|
- if (Object.getPrototypeOf(this) !== instancePrototype) {
|
|
|
- throw new BindingError("Use 'new' to construct " + name);
|
|
|
- }
|
|
|
- if (undefined === registeredClass.constructor_body) {
|
|
|
- throw new BindingError(name + ' has no accessible constructor');
|
|
|
- }
|
|
|
- var body = registeredClass.constructor_body[arguments.length];
|
|
|
- if (undefined === body) {
|
|
|
- throw new BindingError(
|
|
|
- 'Tried to invoke ctor of ' +
|
|
|
- name +
|
|
|
- ' with invalid number of parameters (' +
|
|
|
- arguments.length +
|
|
|
- ') - expected (' +
|
|
|
- Object.keys(registeredClass.constructor_body).toString() +
|
|
|
- ') parameters instead!'
|
|
|
- );
|
|
|
- }
|
|
|
- return body.apply(this, arguments);
|
|
|
- });
|
|
|
- var instancePrototype = Object.create(basePrototype, { constructor: { value: constructor } });
|
|
|
- constructor.prototype = instancePrototype;
|
|
|
- var registeredClass = new RegisteredClass(
|
|
|
- name,
|
|
|
- constructor,
|
|
|
- instancePrototype,
|
|
|
- rawDestructor,
|
|
|
- baseClass,
|
|
|
- getActualType,
|
|
|
- upcast,
|
|
|
- downcast
|
|
|
- );
|
|
|
- var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false);
|
|
|
- var pointerConverter = new RegisteredPointer(name + '*', registeredClass, false, false, false);
|
|
|
- var constPointerConverter = new RegisteredPointer(name + ' const*', registeredClass, false, true, false);
|
|
|
- registeredPointers[rawType] = { pointerType: pointerConverter, constPointerType: constPointerConverter };
|
|
|
- replacePublicSymbol(legalFunctionName, constructor);
|
|
|
- return [referenceConverter, pointerConverter, constPointerConverter];
|
|
|
- }
|
|
|
- );
|
|
|
- }
|
|
|
- function heap32VectorToArray(count, firstElement) {
|
|
|
- var array = [];
|
|
|
- for (var i = 0; i < count; i++) {
|
|
|
- array.push(HEAP32[(firstElement >> 2) + i]);
|
|
|
- }
|
|
|
- return array;
|
|
|
- }
|
|
|
- function __embind_register_class_constructor(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) {
|
|
|
- assert(argCount > 0);
|
|
|
- var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
|
|
|
- invoker = embind__requireFunction(invokerSignature, invoker);
|
|
|
- whenDependentTypesAreResolved([], [rawClassType], function (classType) {
|
|
|
- classType = classType[0];
|
|
|
- var humanName = 'constructor ' + classType.name;
|
|
|
- if (undefined === classType.registeredClass.constructor_body) {
|
|
|
- classType.registeredClass.constructor_body = [];
|
|
|
- }
|
|
|
- if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) {
|
|
|
- throw new BindingError(
|
|
|
- 'Cannot register multiple constructors with identical number of parameters (' +
|
|
|
- (argCount - 1) +
|
|
|
- ") for class '" +
|
|
|
- classType.name +
|
|
|
- "'! Overload resolution is currently only performed using the parameter count, not actual type info!"
|
|
|
- );
|
|
|
- }
|
|
|
- classType.registeredClass.constructor_body[argCount - 1] = function unboundTypeHandler() {
|
|
|
- throwUnboundTypeError('Cannot construct ' + classType.name + ' due to unbound types', rawArgTypes);
|
|
|
- };
|
|
|
- whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
|
|
|
- argTypes.splice(1, 0, null);
|
|
|
- classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(
|
|
|
- humanName,
|
|
|
- argTypes,
|
|
|
- null,
|
|
|
- invoker,
|
|
|
- rawConstructor
|
|
|
- );
|
|
|
- return [];
|
|
|
- });
|
|
|
- return [];
|
|
|
- });
|
|
|
- }
|
|
|
- function new_(constructor, argumentList) {
|
|
|
- if (!(constructor instanceof Function)) {
|
|
|
- throw new TypeError('new_ called with constructor type ' + typeof constructor + ' which is not a function');
|
|
|
- }
|
|
|
- var dummy = createNamedFunction(constructor.name || 'unknownFunctionName', function () {});
|
|
|
- dummy.prototype = constructor.prototype;
|
|
|
- var obj = new dummy();
|
|
|
- var r = constructor.apply(obj, argumentList);
|
|
|
- return r instanceof Object ? r : obj;
|
|
|
- }
|
|
|
- function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) {
|
|
|
- var argCount = argTypes.length;
|
|
|
- if (argCount < 2) {
|
|
|
- throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");
|
|
|
- }
|
|
|
- var isClassMethodFunc = argTypes[1] !== null && classType !== null;
|
|
|
- var needsDestructorStack = false;
|
|
|
- for (var i = 1; i < argTypes.length; ++i) {
|
|
|
- if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
|
|
|
- needsDestructorStack = true;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- var returns = argTypes[0].name !== 'void';
|
|
|
- var argsList = '';
|
|
|
- var argsListWired = '';
|
|
|
- for (var i = 0; i < argCount - 2; ++i) {
|
|
|
- argsList += (i !== 0 ? ', ' : '') + 'arg' + i;
|
|
|
- argsListWired += (i !== 0 ? ', ' : '') + 'arg' + i + 'Wired';
|
|
|
- }
|
|
|
- var invokerFnBody =
|
|
|
- 'return function ' +
|
|
|
- makeLegalFunctionName(humanName) +
|
|
|
- '(' +
|
|
|
- argsList +
|
|
|
- ') {\nif (arguments.length !== ' +
|
|
|
- (argCount - 2) +
|
|
|
- ') {\n' +
|
|
|
- "throwBindingError('function " +
|
|
|
- humanName +
|
|
|
- " called with ' + arguments.length + ' arguments, expected " +
|
|
|
- (argCount - 2) +
|
|
|
- " args!');\n" +
|
|
|
- '}\n';
|
|
|
- if (needsDestructorStack) {
|
|
|
- invokerFnBody += 'var destructors = [];\n';
|
|
|
- }
|
|
|
- var dtorStack = needsDestructorStack ? 'destructors' : 'null';
|
|
|
- var args1 = ['throwBindingError', 'invoker', 'fn', 'runDestructors', 'retType', 'classParam'];
|
|
|
- var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];
|
|
|
- if (isClassMethodFunc) {
|
|
|
- invokerFnBody += 'var thisWired = classParam.toWireType(' + dtorStack + ', this);\n';
|
|
|
- }
|
|
|
- for (var i = 0; i < argCount - 2; ++i) {
|
|
|
- invokerFnBody +=
|
|
|
- 'var arg' + i + 'Wired = argType' + i + '.toWireType(' + dtorStack + ', arg' + i + '); // ' + argTypes[i + 2].name + '\n';
|
|
|
- args1.push('argType' + i);
|
|
|
- args2.push(argTypes[i + 2]);
|
|
|
- }
|
|
|
- if (isClassMethodFunc) {
|
|
|
- argsListWired = 'thisWired' + (argsListWired.length > 0 ? ', ' : '') + argsListWired;
|
|
|
- }
|
|
|
- invokerFnBody += (returns ? 'var rv = ' : '') + 'invoker(fn' + (argsListWired.length > 0 ? ', ' : '') + argsListWired + ');\n';
|
|
|
- if (needsDestructorStack) {
|
|
|
- invokerFnBody += 'runDestructors(destructors);\n';
|
|
|
- } else {
|
|
|
- for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
|
|
|
- var paramName = i === 1 ? 'thisWired' : 'arg' + (i - 2) + 'Wired';
|
|
|
- if (argTypes[i].destructorFunction !== null) {
|
|
|
- invokerFnBody += paramName + '_dtor(' + paramName + '); // ' + argTypes[i].name + '\n';
|
|
|
- args1.push(paramName + '_dtor');
|
|
|
- args2.push(argTypes[i].destructorFunction);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (returns) {
|
|
|
- invokerFnBody += 'var ret = retType.fromWireType(rv);\nreturn ret;\n';
|
|
|
- } else {
|
|
|
- }
|
|
|
- invokerFnBody += '}\n';
|
|
|
- args1.push(invokerFnBody);
|
|
|
- var invokerFunction = new_(Function, args1).apply(null, args2);
|
|
|
- return invokerFunction;
|
|
|
- }
|
|
|
- function __embind_register_class_function(
|
|
|
- rawClassType,
|
|
|
- methodName,
|
|
|
- argCount,
|
|
|
- rawArgTypesAddr,
|
|
|
- invokerSignature,
|
|
|
- rawInvoker,
|
|
|
- context,
|
|
|
- isPureVirtual
|
|
|
- ) {
|
|
|
- var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
|
|
|
- methodName = readLatin1String(methodName);
|
|
|
- rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
|
|
|
- whenDependentTypesAreResolved([], [rawClassType], function (classType) {
|
|
|
- classType = classType[0];
|
|
|
- var humanName = classType.name + '.' + methodName;
|
|
|
- if (methodName.startsWith('@@')) {
|
|
|
- methodName = Symbol[methodName.substring(2)];
|
|
|
- }
|
|
|
- if (isPureVirtual) {
|
|
|
- classType.registeredClass.pureVirtualFunctions.push(methodName);
|
|
|
- }
|
|
|
- function unboundTypesHandler() {
|
|
|
- throwUnboundTypeError('Cannot call ' + humanName + ' due to unbound types', rawArgTypes);
|
|
|
- }
|
|
|
- var proto = classType.registeredClass.instancePrototype;
|
|
|
- var method = proto[methodName];
|
|
|
- if (
|
|
|
- undefined === method ||
|
|
|
- (undefined === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2)
|
|
|
- ) {
|
|
|
- unboundTypesHandler.argCount = argCount - 2;
|
|
|
- unboundTypesHandler.className = classType.name;
|
|
|
- proto[methodName] = unboundTypesHandler;
|
|
|
- } else {
|
|
|
- ensureOverloadTable(proto, methodName, humanName);
|
|
|
- proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler;
|
|
|
- }
|
|
|
- whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
|
|
|
- var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context);
|
|
|
- if (undefined === proto[methodName].overloadTable) {
|
|
|
- memberFunction.argCount = argCount - 2;
|
|
|
- proto[methodName] = memberFunction;
|
|
|
- } else {
|
|
|
- proto[methodName].overloadTable[argCount - 2] = memberFunction;
|
|
|
- }
|
|
|
- return [];
|
|
|
- });
|
|
|
- return [];
|
|
|
- });
|
|
|
- }
|
|
|
- function validateThis(this_, classType, humanName) {
|
|
|
- if (!(this_ instanceof Object)) {
|
|
|
- throwBindingError(humanName + ' with invalid "this": ' + this_);
|
|
|
- }
|
|
|
- if (!(this_ instanceof classType.registeredClass.constructor)) {
|
|
|
- throwBindingError(humanName + ' incompatible with "this" of type ' + this_.constructor.name);
|
|
|
- }
|
|
|
- if (!this_.$$.ptr) {
|
|
|
- throwBindingError('cannot call emscripten binding method ' + humanName + ' on deleted object');
|
|
|
- }
|
|
|
- return upcastPointer(this_.$$.ptr, this_.$$.ptrType.registeredClass, classType.registeredClass);
|
|
|
- }
|
|
|
- function __embind_register_class_property(
|
|
|
- classType,
|
|
|
- fieldName,
|
|
|
- getterReturnType,
|
|
|
- getterSignature,
|
|
|
- getter,
|
|
|
- getterContext,
|
|
|
- setterArgumentType,
|
|
|
- setterSignature,
|
|
|
- setter,
|
|
|
- setterContext
|
|
|
- ) {
|
|
|
- fieldName = readLatin1String(fieldName);
|
|
|
- getter = embind__requireFunction(getterSignature, getter);
|
|
|
- whenDependentTypesAreResolved([], [classType], function (classType) {
|
|
|
- classType = classType[0];
|
|
|
- var humanName = classType.name + '.' + fieldName;
|
|
|
- var desc = {
|
|
|
- get: function () {
|
|
|
- throwUnboundTypeError('Cannot access ' + humanName + ' due to unbound types', [getterReturnType, setterArgumentType]);
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- };
|
|
|
- if (setter) {
|
|
|
- desc.set = function () {
|
|
|
- throwUnboundTypeError('Cannot access ' + humanName + ' due to unbound types', [getterReturnType, setterArgumentType]);
|
|
|
- };
|
|
|
- } else {
|
|
|
- desc.set = function (v) {
|
|
|
- throwBindingError(humanName + ' is a read-only property');
|
|
|
- };
|
|
|
- }
|
|
|
- Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc);
|
|
|
- whenDependentTypesAreResolved([], setter ? [getterReturnType, setterArgumentType] : [getterReturnType], function (types) {
|
|
|
- var getterReturnType = types[0];
|
|
|
- var desc = {
|
|
|
- get: function () {
|
|
|
- var ptr = validateThis(this, classType, humanName + ' getter');
|
|
|
- return getterReturnType['fromWireType'](getter(getterContext, ptr));
|
|
|
- },
|
|
|
- enumerable: true
|
|
|
- };
|
|
|
- if (setter) {
|
|
|
- setter = embind__requireFunction(setterSignature, setter);
|
|
|
- var setterArgumentType = types[1];
|
|
|
- desc.set = function (v) {
|
|
|
- var ptr = validateThis(this, classType, humanName + ' setter');
|
|
|
- var destructors = [];
|
|
|
- setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, v));
|
|
|
- runDestructors(destructors);
|
|
|
- };
|
|
|
- }
|
|
|
- Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc);
|
|
|
- return [];
|
|
|
- });
|
|
|
- return [];
|
|
|
- });
|
|
|
- }
|
|
|
- var emval_free_list = [];
|
|
|
- var emval_handle_array = [{}, { value: undefined }, { value: null }, { value: true }, { value: false }];
|
|
|
- function __emval_decref(handle) {
|
|
|
- if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
|
|
|
- emval_handle_array[handle] = undefined;
|
|
|
- emval_free_list.push(handle);
|
|
|
- }
|
|
|
- }
|
|
|
- function count_emval_handles() {
|
|
|
- var count = 0;
|
|
|
- for (var i = 5; i < emval_handle_array.length; ++i) {
|
|
|
- if (emval_handle_array[i] !== undefined) {
|
|
|
- ++count;
|
|
|
- }
|
|
|
- }
|
|
|
- return count;
|
|
|
- }
|
|
|
- function get_first_emval() {
|
|
|
- for (var i = 5; i < emval_handle_array.length; ++i) {
|
|
|
- if (emval_handle_array[i] !== undefined) {
|
|
|
- return emval_handle_array[i];
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- function init_emval() {
|
|
|
- Module['count_emval_handles'] = count_emval_handles;
|
|
|
- Module['get_first_emval'] = get_first_emval;
|
|
|
- }
|
|
|
- var Emval = {
|
|
|
- toValue: function (handle) {
|
|
|
- if (!handle) {
|
|
|
- throwBindingError('Cannot use deleted val. handle = ' + handle);
|
|
|
- }
|
|
|
- return emval_handle_array[handle].value;
|
|
|
- },
|
|
|
- toHandle: function (value) {
|
|
|
- switch (value) {
|
|
|
- case undefined: {
|
|
|
- return 1;
|
|
|
- }
|
|
|
- case null: {
|
|
|
- return 2;
|
|
|
- }
|
|
|
- case true: {
|
|
|
- return 3;
|
|
|
- }
|
|
|
- case false: {
|
|
|
- return 4;
|
|
|
- }
|
|
|
- default: {
|
|
|
- var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length;
|
|
|
- emval_handle_array[handle] = { refcount: 1, value: value };
|
|
|
- return handle;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- function __embind_register_emval(rawType, name) {
|
|
|
- name = readLatin1String(name);
|
|
|
- registerType(rawType, {
|
|
|
- name: name,
|
|
|
- fromWireType: function (handle) {
|
|
|
- var rv = Emval.toValue(handle);
|
|
|
- __emval_decref(handle);
|
|
|
- return rv;
|
|
|
- },
|
|
|
- toWireType: function (destructors, value) {
|
|
|
- return Emval.toHandle(value);
|
|
|
- },
|
|
|
- argPackAdvance: 8,
|
|
|
- readValueFromPointer: simpleReadValueFromPointer,
|
|
|
- destructorFunction: null
|
|
|
- });
|
|
|
- }
|
|
|
- function enumReadValueFromPointer(name, shift, signed) {
|
|
|
- switch (shift) {
|
|
|
- case 0:
|
|
|
- return function (pointer) {
|
|
|
- var heap = signed ? HEAP8 : HEAPU8;
|
|
|
- return this['fromWireType'](heap[pointer]);
|
|
|
- };
|
|
|
- case 1:
|
|
|
- return function (pointer) {
|
|
|
- var heap = signed ? HEAP16 : HEAPU16;
|
|
|
- return this['fromWireType'](heap[pointer >> 1]);
|
|
|
- };
|
|
|
- case 2:
|
|
|
- return function (pointer) {
|
|
|
- var heap = signed ? HEAP32 : HEAPU32;
|
|
|
- return this['fromWireType'](heap[pointer >> 2]);
|
|
|
- };
|
|
|
- default:
|
|
|
- throw new TypeError('Unknown integer type: ' + name);
|
|
|
- }
|
|
|
- }
|
|
|
- function __embind_register_enum(rawType, name, size, isSigned) {
|
|
|
- var shift = getShiftFromSize(size);
|
|
|
- name = readLatin1String(name);
|
|
|
- function ctor() {}
|
|
|
- ctor.values = {};
|
|
|
- registerType(rawType, {
|
|
|
- name: name,
|
|
|
- constructor: ctor,
|
|
|
- fromWireType: function (c) {
|
|
|
- return this.constructor.values[c];
|
|
|
- },
|
|
|
- toWireType: function (destructors, c) {
|
|
|
- return c.value;
|
|
|
- },
|
|
|
- argPackAdvance: 8,
|
|
|
- readValueFromPointer: enumReadValueFromPointer(name, shift, isSigned),
|
|
|
- destructorFunction: null
|
|
|
- });
|
|
|
- exposePublicSymbol(name, ctor);
|
|
|
- }
|
|
|
- function requireRegisteredType(rawType, humanName) {
|
|
|
- var impl = registeredTypes[rawType];
|
|
|
- if (undefined === impl) {
|
|
|
- throwBindingError(humanName + ' has unknown type ' + getTypeName(rawType));
|
|
|
- }
|
|
|
- return impl;
|
|
|
- }
|
|
|
- function __embind_register_enum_value(rawEnumType, name, enumValue) {
|
|
|
- var enumType = requireRegisteredType(rawEnumType, 'enum');
|
|
|
- name = readLatin1String(name);
|
|
|
- var Enum = enumType.constructor;
|
|
|
- var Value = Object.create(enumType.constructor.prototype, {
|
|
|
- value: { value: enumValue },
|
|
|
- constructor: { value: createNamedFunction(enumType.name + '_' + name, function () {}) }
|
|
|
- });
|
|
|
- Enum.values[enumValue] = Value;
|
|
|
- Enum[name] = Value;
|
|
|
- }
|
|
|
- function _embind_repr(v) {
|
|
|
- if (v === null) {
|
|
|
- return 'null';
|
|
|
- }
|
|
|
- var t = typeof v;
|
|
|
- if (t === 'object' || t === 'array' || t === 'function') {
|
|
|
- return v.toString();
|
|
|
- } else {
|
|
|
- return '' + v;
|
|
|
- }
|
|
|
- }
|
|
|
- function floatReadValueFromPointer(name, shift) {
|
|
|
- switch (shift) {
|
|
|
- case 2:
|
|
|
- return function (pointer) {
|
|
|
- return this['fromWireType'](HEAPF32[pointer >> 2]);
|
|
|
- };
|
|
|
- case 3:
|
|
|
- return function (pointer) {
|
|
|
- return this['fromWireType'](HEAPF64[pointer >> 3]);
|
|
|
- };
|
|
|
- default:
|
|
|
- throw new TypeError('Unknown float type: ' + name);
|
|
|
- }
|
|
|
- }
|
|
|
- function __embind_register_float(rawType, name, size) {
|
|
|
- var shift = getShiftFromSize(size);
|
|
|
- name = readLatin1String(name);
|
|
|
- registerType(rawType, {
|
|
|
- name: name,
|
|
|
- fromWireType: function (value) {
|
|
|
- return value;
|
|
|
- },
|
|
|
- toWireType: function (destructors, value) {
|
|
|
- if (typeof value !== 'number' && typeof value !== 'boolean') {
|
|
|
- throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name);
|
|
|
- }
|
|
|
- return value;
|
|
|
- },
|
|
|
- argPackAdvance: 8,
|
|
|
- readValueFromPointer: floatReadValueFromPointer(name, shift),
|
|
|
- destructorFunction: null
|
|
|
- });
|
|
|
- }
|
|
|
- function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn) {
|
|
|
- var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
|
|
|
- name = readLatin1String(name);
|
|
|
- rawInvoker = embind__requireFunction(signature, rawInvoker);
|
|
|
- exposePublicSymbol(
|
|
|
- name,
|
|
|
- function () {
|
|
|
- throwUnboundTypeError('Cannot call ' + name + ' due to unbound types', argTypes);
|
|
|
- },
|
|
|
- argCount - 1
|
|
|
- );
|
|
|
- whenDependentTypesAreResolved([], argTypes, function (argTypes) {
|
|
|
- var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1));
|
|
|
- replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn), argCount - 1);
|
|
|
- return [];
|
|
|
- });
|
|
|
- }
|
|
|
- function integerReadValueFromPointer(name, shift, signed) {
|
|
|
- switch (shift) {
|
|
|
- case 0:
|
|
|
- return signed
|
|
|
- ? function readS8FromPointer(pointer) {
|
|
|
- return HEAP8[pointer];
|
|
|
- }
|
|
|
- : function readU8FromPointer(pointer) {
|
|
|
- return HEAPU8[pointer];
|
|
|
- };
|
|
|
- case 1:
|
|
|
- return signed
|
|
|
- ? function readS16FromPointer(pointer) {
|
|
|
- return HEAP16[pointer >> 1];
|
|
|
- }
|
|
|
- : function readU16FromPointer(pointer) {
|
|
|
- return HEAPU16[pointer >> 1];
|
|
|
- };
|
|
|
- case 2:
|
|
|
- return signed
|
|
|
- ? function readS32FromPointer(pointer) {
|
|
|
- return HEAP32[pointer >> 2];
|
|
|
- }
|
|
|
- : function readU32FromPointer(pointer) {
|
|
|
- return HEAPU32[pointer >> 2];
|
|
|
- };
|
|
|
- default:
|
|
|
- throw new TypeError('Unknown integer type: ' + name);
|
|
|
- }
|
|
|
- }
|
|
|
- function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
|
|
|
- name = readLatin1String(name);
|
|
|
- if (maxRange === -1) {
|
|
|
- maxRange = 4294967295;
|
|
|
- }
|
|
|
- var shift = getShiftFromSize(size);
|
|
|
- var fromWireType = function (value) {
|
|
|
- return value;
|
|
|
- };
|
|
|
- if (minRange === 0) {
|
|
|
- var bitshift = 32 - 8 * size;
|
|
|
- fromWireType = function (value) {
|
|
|
- return (value << bitshift) >>> bitshift;
|
|
|
- };
|
|
|
- }
|
|
|
- var isUnsignedType = name.includes('unsigned');
|
|
|
- registerType(primitiveType, {
|
|
|
- name: name,
|
|
|
- fromWireType: fromWireType,
|
|
|
- toWireType: function (destructors, value) {
|
|
|
- if (typeof value !== 'number' && typeof value !== 'boolean') {
|
|
|
- throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name);
|
|
|
- }
|
|
|
- if (value < minRange || value > maxRange) {
|
|
|
- throw new TypeError(
|
|
|
- 'Passing a number "' +
|
|
|
- _embind_repr(value) +
|
|
|
- '" from JS side to C/C++ side to an argument of type "' +
|
|
|
- name +
|
|
|
- '", which is outside the valid range [' +
|
|
|
- minRange +
|
|
|
- ', ' +
|
|
|
- maxRange +
|
|
|
- ']!'
|
|
|
- );
|
|
|
- }
|
|
|
- return isUnsignedType ? value >>> 0 : value | 0;
|
|
|
- },
|
|
|
- argPackAdvance: 8,
|
|
|
- readValueFromPointer: integerReadValueFromPointer(name, shift, minRange !== 0),
|
|
|
- destructorFunction: null
|
|
|
- });
|
|
|
- }
|
|
|
- function __embind_register_memory_view(rawType, dataTypeIndex, name) {
|
|
|
- var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
|
|
|
- var TA = typeMapping[dataTypeIndex];
|
|
|
- function decodeMemoryView(handle) {
|
|
|
- handle = handle >> 2;
|
|
|
- var heap = HEAPU32;
|
|
|
- var size = heap[handle];
|
|
|
- var data = heap[handle + 1];
|
|
|
- return new TA(buffer, data, size);
|
|
|
- }
|
|
|
- name = readLatin1String(name);
|
|
|
- registerType(
|
|
|
- rawType,
|
|
|
- { name: name, fromWireType: decodeMemoryView, argPackAdvance: 8, readValueFromPointer: decodeMemoryView },
|
|
|
- { ignoreDuplicateRegistrations: true }
|
|
|
- );
|
|
|
- }
|
|
|
- function __embind_register_std_string(rawType, name) {
|
|
|
- name = readLatin1String(name);
|
|
|
- var stdStringIsUTF8 = name === 'std::string';
|
|
|
- registerType(rawType, {
|
|
|
- name: name,
|
|
|
- fromWireType: function (value) {
|
|
|
- var length = HEAPU32[value >> 2];
|
|
|
- var str;
|
|
|
- if (stdStringIsUTF8) {
|
|
|
- var decodeStartPtr = value + 4;
|
|
|
- for (var i = 0; i <= length; ++i) {
|
|
|
- var currentBytePtr = value + 4 + i;
|
|
|
- if (i == length || HEAPU8[currentBytePtr] == 0) {
|
|
|
- var maxRead = currentBytePtr - decodeStartPtr;
|
|
|
- var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
|
|
|
- if (str === undefined) {
|
|
|
- str = stringSegment;
|
|
|
- } else {
|
|
|
- str += String.fromCharCode(0);
|
|
|
- str += stringSegment;
|
|
|
- }
|
|
|
- decodeStartPtr = currentBytePtr + 1;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- var a = new Array(length);
|
|
|
- for (var i = 0; i < length; ++i) {
|
|
|
- a[i] = String.fromCharCode(HEAPU8[value + 4 + i]);
|
|
|
- }
|
|
|
- str = a.join('');
|
|
|
- }
|
|
|
- _free(value);
|
|
|
- return str;
|
|
|
- },
|
|
|
- toWireType: function (destructors, value) {
|
|
|
- if (value instanceof ArrayBuffer) {
|
|
|
- value = new Uint8Array(value);
|
|
|
- }
|
|
|
- var getLength;
|
|
|
- var valueIsOfTypeString = typeof value === 'string';
|
|
|
- if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) {
|
|
|
- throwBindingError('Cannot pass non-string to std::string');
|
|
|
- }
|
|
|
- if (stdStringIsUTF8 && valueIsOfTypeString) {
|
|
|
- getLength = function () {
|
|
|
- return lengthBytesUTF8(value);
|
|
|
- };
|
|
|
- } else {
|
|
|
- getLength = function () {
|
|
|
- return value.length;
|
|
|
- };
|
|
|
- }
|
|
|
- var length = getLength();
|
|
|
- var ptr = _malloc(4 + length + 1);
|
|
|
- HEAPU32[ptr >> 2] = length;
|
|
|
- if (stdStringIsUTF8 && valueIsOfTypeString) {
|
|
|
- stringToUTF8(value, ptr + 4, length + 1);
|
|
|
- } else {
|
|
|
- if (valueIsOfTypeString) {
|
|
|
- for (var i = 0; i < length; ++i) {
|
|
|
- var charCode = value.charCodeAt(i);
|
|
|
- if (charCode > 255) {
|
|
|
- _free(ptr);
|
|
|
- throwBindingError('String has UTF-16 code units that do not fit in 8 bits');
|
|
|
- }
|
|
|
- HEAPU8[ptr + 4 + i] = charCode;
|
|
|
- }
|
|
|
- } else {
|
|
|
- for (var i = 0; i < length; ++i) {
|
|
|
- HEAPU8[ptr + 4 + i] = value[i];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (destructors !== null) {
|
|
|
- destructors.push(_free, ptr);
|
|
|
- }
|
|
|
- return ptr;
|
|
|
- },
|
|
|
- argPackAdvance: 8,
|
|
|
- readValueFromPointer: simpleReadValueFromPointer,
|
|
|
- destructorFunction: function (ptr) {
|
|
|
- _free(ptr);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- function __embind_register_std_wstring(rawType, charSize, name) {
|
|
|
- name = readLatin1String(name);
|
|
|
- var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
|
|
|
- if (charSize === 2) {
|
|
|
- decodeString = UTF16ToString;
|
|
|
- encodeString = stringToUTF16;
|
|
|
- lengthBytesUTF = lengthBytesUTF16;
|
|
|
- getHeap = function () {
|
|
|
- return HEAPU16;
|
|
|
- };
|
|
|
- shift = 1;
|
|
|
- } else if (charSize === 4) {
|
|
|
- decodeString = UTF32ToString;
|
|
|
- encodeString = stringToUTF32;
|
|
|
- lengthBytesUTF = lengthBytesUTF32;
|
|
|
- getHeap = function () {
|
|
|
- return HEAPU32;
|
|
|
- };
|
|
|
- shift = 2;
|
|
|
- }
|
|
|
- registerType(rawType, {
|
|
|
- name: name,
|
|
|
- fromWireType: function (value) {
|
|
|
- var length = HEAPU32[value >> 2];
|
|
|
- var HEAP = getHeap();
|
|
|
- var str;
|
|
|
- var decodeStartPtr = value + 4;
|
|
|
- for (var i = 0; i <= length; ++i) {
|
|
|
- var currentBytePtr = value + 4 + i * charSize;
|
|
|
- if (i == length || HEAP[currentBytePtr >> shift] == 0) {
|
|
|
- var maxReadBytes = currentBytePtr - decodeStartPtr;
|
|
|
- var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
|
|
|
- if (str === undefined) {
|
|
|
- str = stringSegment;
|
|
|
- } else {
|
|
|
- str += String.fromCharCode(0);
|
|
|
- str += stringSegment;
|
|
|
- }
|
|
|
- decodeStartPtr = currentBytePtr + charSize;
|
|
|
- }
|
|
|
- }
|
|
|
- _free(value);
|
|
|
- return str;
|
|
|
- },
|
|
|
- toWireType: function (destructors, value) {
|
|
|
- if (!(typeof value === 'string')) {
|
|
|
- throwBindingError('Cannot pass non-string to C++ string type ' + name);
|
|
|
- }
|
|
|
- var length = lengthBytesUTF(value);
|
|
|
- var ptr = _malloc(4 + length + charSize);
|
|
|
- HEAPU32[ptr >> 2] = length >> shift;
|
|
|
- encodeString(value, ptr + 4, length + charSize);
|
|
|
- if (destructors !== null) {
|
|
|
- destructors.push(_free, ptr);
|
|
|
- }
|
|
|
- return ptr;
|
|
|
- },
|
|
|
- argPackAdvance: 8,
|
|
|
- readValueFromPointer: simpleReadValueFromPointer,
|
|
|
- destructorFunction: function (ptr) {
|
|
|
- _free(ptr);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- function __embind_register_value_array(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) {
|
|
|
- tupleRegistrations[rawType] = {
|
|
|
- name: readLatin1String(name),
|
|
|
- rawConstructor: embind__requireFunction(constructorSignature, rawConstructor),
|
|
|
- rawDestructor: embind__requireFunction(destructorSignature, rawDestructor),
|
|
|
- elements: []
|
|
|
- };
|
|
|
- }
|
|
|
- function __embind_register_value_array_element(
|
|
|
- rawTupleType,
|
|
|
- getterReturnType,
|
|
|
- getterSignature,
|
|
|
- getter,
|
|
|
- getterContext,
|
|
|
- setterArgumentType,
|
|
|
- setterSignature,
|
|
|
- setter,
|
|
|
- setterContext
|
|
|
- ) {
|
|
|
- tupleRegistrations[rawTupleType].elements.push({
|
|
|
- getterReturnType: getterReturnType,
|
|
|
- getter: embind__requireFunction(getterSignature, getter),
|
|
|
- getterContext: getterContext,
|
|
|
- setterArgumentType: setterArgumentType,
|
|
|
- setter: embind__requireFunction(setterSignature, setter),
|
|
|
- setterContext: setterContext
|
|
|
- });
|
|
|
- }
|
|
|
- function __embind_register_value_object(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) {
|
|
|
- structRegistrations[rawType] = {
|
|
|
- name: readLatin1String(name),
|
|
|
- rawConstructor: embind__requireFunction(constructorSignature, rawConstructor),
|
|
|
- rawDestructor: embind__requireFunction(destructorSignature, rawDestructor),
|
|
|
- fields: []
|
|
|
- };
|
|
|
- }
|
|
|
- function __embind_register_value_object_field(
|
|
|
- structType,
|
|
|
- fieldName,
|
|
|
- getterReturnType,
|
|
|
- getterSignature,
|
|
|
- getter,
|
|
|
- getterContext,
|
|
|
- setterArgumentType,
|
|
|
- setterSignature,
|
|
|
- setter,
|
|
|
- setterContext
|
|
|
- ) {
|
|
|
- structRegistrations[structType].fields.push({
|
|
|
- fieldName: readLatin1String(fieldName),
|
|
|
- getterReturnType: getterReturnType,
|
|
|
- getter: embind__requireFunction(getterSignature, getter),
|
|
|
- getterContext: getterContext,
|
|
|
- setterArgumentType: setterArgumentType,
|
|
|
- setter: embind__requireFunction(setterSignature, setter),
|
|
|
- setterContext: setterContext
|
|
|
- });
|
|
|
- }
|
|
|
- function __embind_register_void(rawType, name) {
|
|
|
- name = readLatin1String(name);
|
|
|
- registerType(rawType, {
|
|
|
- isVoid: true,
|
|
|
- name: name,
|
|
|
- argPackAdvance: 0,
|
|
|
- fromWireType: function () {
|
|
|
- return undefined;
|
|
|
- },
|
|
|
- toWireType: function (destructors, o) {
|
|
|
- return undefined;
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- function __emval_incref(handle) {
|
|
|
- if (handle > 4) {
|
|
|
- emval_handle_array[handle].refcount += 1;
|
|
|
- }
|
|
|
- }
|
|
|
- function __emval_take_value(type, argv) {
|
|
|
- type = requireRegisteredType(type, '_emval_take_value');
|
|
|
- var v = type['readValueFromPointer'](argv);
|
|
|
- return Emval.toHandle(v);
|
|
|
- }
|
|
|
- function _abort() {
|
|
|
- abort('');
|
|
|
- }
|
|
|
- function _emscripten_memcpy_big(dest, src, num) {
|
|
|
- HEAPU8.copyWithin(dest, src, src + num);
|
|
|
- }
|
|
|
- function emscripten_realloc_buffer(size) {
|
|
|
- try {
|
|
|
- wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16);
|
|
|
- updateGlobalBufferAndViews(wasmMemory.buffer);
|
|
|
- return 1;
|
|
|
- } catch (e) {}
|
|
|
- }
|
|
|
- function _emscripten_resize_heap(requestedSize) {
|
|
|
- var oldSize = HEAPU8.length;
|
|
|
- requestedSize = requestedSize >>> 0;
|
|
|
- var maxHeapSize = 2147483648;
|
|
|
- if (requestedSize > maxHeapSize) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
|
|
|
- var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
|
|
|
- overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
|
|
|
- var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
|
|
|
- var replacement = emscripten_realloc_buffer(newSize);
|
|
|
- if (replacement) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- 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) {
|
|
|
- if (ENV[x] === undefined) delete env[x];
|
|
|
- else env[x] = ENV[x];
|
|
|
- }
|
|
|
- var strings = [];
|
|
|
- for (var x in env) {
|
|
|
- strings.push(x + '=' + env[x]);
|
|
|
- }
|
|
|
- getEnvStrings.strings = strings;
|
|
|
- }
|
|
|
- return getEnvStrings.strings;
|
|
|
- }
|
|
|
- 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
|
|
|
- return function () {
|
|
|
- abort('randomDevice');
|
|
|
- };
|
|
|
- }
|
|
|
- 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 (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) {
|
|
|
- abort();
|
|
|
- }
|
|
|
- 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;
|
|
|
- parent.timestamp = node.timestamp;
|
|
|
- }
|
|
|
- return node;
|
|
|
- },
|
|
|
- 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);
|
|
|
- },
|
|
|
- resizeFileStorage: function (node, newSize) {
|
|
|
- if (node.usedBytes == newSize) return;
|
|
|
- if (newSize == 0) {
|
|
|
- node.contents = null;
|
|
|
- node.usedBytes = 0;
|
|
|
- } else {
|
|
|
- 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;
|
|
|
- }
|
|
|
- },
|
|
|
- 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.parent.timestamp = Date.now();
|
|
|
- old_node.name = new_name;
|
|
|
- new_dir.contents[new_name] = old_node;
|
|
|
- new_dir.timestamp = old_node.parent.timestamp;
|
|
|
- old_node.parent = new_dir;
|
|
|
- },
|
|
|
- unlink: function (parent, name) {
|
|
|
- delete parent.contents[name];
|
|
|
- parent.timestamp = Date.now();
|
|
|
- },
|
|
|
- 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];
|
|
|
- parent.timestamp = Date.now();
|
|
|
- },
|
|
|
- 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);
|
|
|
- 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) {
|
|
|
- if (buffer.buffer === HEAP8.buffer) {
|
|
|
- canOwn = false;
|
|
|
- }
|
|
|
- if (!length) return 0;
|
|
|
- var node = stream.node;
|
|
|
- node.timestamp = Date.now();
|
|
|
- if (buffer.subarray && (!node.contents || node.contents.subarray)) {
|
|
|
- if (canOwn) {
|
|
|
- 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) {
|
|
|
- if (address !== 0) {
|
|
|
- throw new FS.ErrnoError(28);
|
|
|
- }
|
|
|
- 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;
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- function asyncLoad(url, onload, onerror, noRunDep) {
|
|
|
- var dep = !noRunDep ? getUniqueRunDependency('al ' + url) : '';
|
|
|
- readAsync(
|
|
|
- url,
|
|
|
- function (arrayBuffer) {
|
|
|
- assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
|
|
|
- onload(new Uint8Array(arrayBuffer));
|
|
|
- if (dep) removeRunDependency(dep);
|
|
|
- },
|
|
|
- function (event) {
|
|
|
- if (onerror) {
|
|
|
- onerror();
|
|
|
- } else {
|
|
|
- throw 'Loading data file "' + url + '" failed.';
|
|
|
- }
|
|
|
- }
|
|
|
- );
|
|
|
- if (dep) addRunDependency(dep);
|
|
|
- }
|
|
|
- var FS = {
|
|
|
- root: null,
|
|
|
- mounts: [],
|
|
|
- devices: {},
|
|
|
- streams: [],
|
|
|
- nextInode: 1,
|
|
|
- nameTable: null,
|
|
|
- currentPath: '/',
|
|
|
- initialized: false,
|
|
|
- ignorePermissions: true,
|
|
|
- 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.includes('r') && !(node.mode & 292)) {
|
|
|
- return 2;
|
|
|
- } else if (perms.includes('w') && !(node.mode & 146)) {
|
|
|
- return 2;
|
|
|
- } else if (perms.includes('x') && !(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) {
|
|
|
- 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) {
|
|
|
- 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.includes(current.mount)) {
|
|
|
- FS.destroyNode(current);
|
|
|
- }
|
|
|
- current = next;
|
|
|
- }
|
|
|
- });
|
|
|
- node.mounted = null;
|
|
|
- var idx = node.mount.mounts.indexOf(mount);
|
|
|
- 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);
|
|
|
- }
|
|
|
- }
|
|
|
- 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);
|
|
|
- }
|
|
|
- },
|
|
|
- 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);
|
|
|
- }
|
|
|
- parent.node_ops.rmdir(parent, name);
|
|
|
- FS.destroyNode(node);
|
|
|
- },
|
|
|
- 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);
|
|
|
- }
|
|
|
- parent.node_ops.unlink(parent, name);
|
|
|
- FS.destroyNode(node);
|
|
|
- },
|
|
|
- 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),
|
|
|
- id: node.id,
|
|
|
- flags: flags,
|
|
|
- mode: node.mode,
|
|
|
- seekable: true,
|
|
|
- position: 0,
|
|
|
- stream_ops: node.stream_ops,
|
|
|
- node_ops: node.node_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;
|
|
|
- }
|
|
|
- }
|
|
|
- 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;
|
|
|
- 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');
|
|
|
- var proc_self = 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);
|
|
|
- },
|
|
|
- ensureErrnoError: function () {
|
|
|
- if (FS.ErrnoError) return;
|
|
|
- FS.ErrnoError = function ErrnoError(errno, node) {
|
|
|
- this.node = node;
|
|
|
- this.setErrno = function (errno) {
|
|
|
- this.errno = errno;
|
|
|
- };
|
|
|
- this.setErrno(errno);
|
|
|
- this.message = 'FS error';
|
|
|
- };
|
|
|
- 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) {
|
|
|
- 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);
|
|
|
- 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') {
|
|
|
- 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;
|
|
|
- }
|
|
|
- };
|
|
|
- var SYSCALLS = {
|
|
|
- mappings: {},
|
|
|
- DEFAULT_POLLMASK: 5,
|
|
|
- calculateAt: function (dirfd, path, allowEmpty) {
|
|
|
- if (path[0] === '/') {
|
|
|
- return path;
|
|
|
- }
|
|
|
- var dir;
|
|
|
- if (dirfd === -100) {
|
|
|
- dir = FS.cwd();
|
|
|
- } else {
|
|
|
- var dirstream = FS.getStream(dirfd);
|
|
|
- if (!dirstream) throw new FS.ErrnoError(8);
|
|
|
- dir = dirstream.path;
|
|
|
- }
|
|
|
- if (path.length == 0) {
|
|
|
- if (!allowEmpty) {
|
|
|
- throw new FS.ErrnoError(44);
|
|
|
- }
|
|
|
- return dir;
|
|
|
- }
|
|
|
- return PATH.join2(dir, 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;
|
|
|
- }
|
|
|
- HEAP32[buf >> 2] = stat.dev;
|
|
|
- HEAP32[(buf + 4) >> 2] = 0;
|
|
|
- HEAP32[(buf + 8) >> 2] = stat.ino;
|
|
|
- HEAP32[(buf + 12) >> 2] = stat.mode;
|
|
|
- HEAP32[(buf + 16) >> 2] = stat.nlink;
|
|
|
- HEAP32[(buf + 20) >> 2] = stat.uid;
|
|
|
- HEAP32[(buf + 24) >> 2] = stat.gid;
|
|
|
- HEAP32[(buf + 28) >> 2] = stat.rdev;
|
|
|
- HEAP32[(buf + 32) >> 2] = 0;
|
|
|
- (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)
|
|
|
- ]),
|
|
|
- (HEAP32[(buf + 40) >> 2] = tempI64[0]),
|
|
|
- (HEAP32[(buf + 44) >> 2] = tempI64[1]);
|
|
|
- HEAP32[(buf + 48) >> 2] = 4096;
|
|
|
- HEAP32[(buf + 52) >> 2] = stat.blocks;
|
|
|
- HEAP32[(buf + 56) >> 2] = (stat.atime.getTime() / 1e3) | 0;
|
|
|
- HEAP32[(buf + 60) >> 2] = 0;
|
|
|
- HEAP32[(buf + 64) >> 2] = (stat.mtime.getTime() / 1e3) | 0;
|
|
|
- HEAP32[(buf + 68) >> 2] = 0;
|
|
|
- HEAP32[(buf + 72) >> 2] = (stat.ctime.getTime() / 1e3) | 0;
|
|
|
- HEAP32[(buf + 76) >> 2] = 0;
|
|
|
- (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)
|
|
|
- ]),
|
|
|
- (HEAP32[(buf + 80) >> 2] = tempI64[0]),
|
|
|
- (HEAP32[(buf + 84) >> 2] = tempI64[1]);
|
|
|
- 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 = HEAP8[buf + len];
|
|
|
- stringToUTF8(ret, buf, bufsize + 1);
|
|
|
- HEAP8[buf + len] = endChar;
|
|
|
- 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 = HEAP32[(iov + i * 8) >> 2];
|
|
|
- var len = HEAP32[(iov + (i * 8 + 4)) >> 2];
|
|
|
- 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 = HEAP32[(iov + i * 8) >> 2];
|
|
|
- var len = HEAP32[(iov + (i * 8 + 4)) >> 2];
|
|
|
- var curr = FS.write(stream, HEAP8, ptr, len, offset);
|
|
|
- if (curr < 0) return -1;
|
|
|
- ret += curr;
|
|
|
- }
|
|
|
- return ret;
|
|
|
- },
|
|
|
- varargs: undefined,
|
|
|
- get: function () {
|
|
|
- SYSCALLS.varargs += 4;
|
|
|
- var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
|
|
|
- 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) {
|
|
|
- return low;
|
|
|
- }
|
|
|
- };
|
|
|
- function _environ_get(__environ, environ_buf) {
|
|
|
- var bufSize = 0;
|
|
|
- getEnvStrings().forEach(function (string, i) {
|
|
|
- var ptr = environ_buf + bufSize;
|
|
|
- HEAP32[(__environ + i * 4) >> 2] = ptr;
|
|
|
- writeAsciiToMemory(string, ptr);
|
|
|
- bufSize += string.length + 1;
|
|
|
- });
|
|
|
- return 0;
|
|
|
- }
|
|
|
- function _environ_sizes_get(penviron_count, penviron_buf_size) {
|
|
|
- var strings = getEnvStrings();
|
|
|
- HEAP32[penviron_count >> 2] = strings.length;
|
|
|
- var bufSize = 0;
|
|
|
- strings.forEach(function (string) {
|
|
|
- bufSize += string.length + 1;
|
|
|
- });
|
|
|
- HEAP32[penviron_buf_size >> 2] = bufSize;
|
|
|
- return 0;
|
|
|
- }
|
|
|
- function _fd_close(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) {
|
|
|
- try {
|
|
|
- var stream = SYSCALLS.getStreamFromFD(fd);
|
|
|
- var num = SYSCALLS.doReadv(stream, iov, iovcnt);
|
|
|
- HEAP32[pnum >> 2] = num;
|
|
|
- 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) {
|
|
|
- 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)
|
|
|
- ]),
|
|
|
- (HEAP32[newOffset >> 2] = tempI64[0]),
|
|
|
- (HEAP32[(newOffset + 4) >> 2] = tempI64[1]);
|
|
|
- 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) {
|
|
|
- try {
|
|
|
- var stream = SYSCALLS.getStreamFromFD(fd);
|
|
|
- var num = SYSCALLS.doWritev(stream, iov, iovcnt);
|
|
|
- HEAP32[pnum >> 2] = num;
|
|
|
- return 0;
|
|
|
- } catch (e) {
|
|
|
- if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
|
- return e.errno;
|
|
|
- }
|
|
|
- }
|
|
|
- function _setTempRet0(val) {
|
|
|
- setTempRet0(val);
|
|
|
- }
|
|
|
- function __isLeapYear(year) {
|
|
|
- return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
|
|
|
- }
|
|
|
- function __arraySum(array, index) {
|
|
|
- var sum = 0;
|
|
|
- for (var i = 0; i <= index; sum += array[i++]) {}
|
|
|
- return sum;
|
|
|
- }
|
|
|
- var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
|
|
|
- var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
|
|
|
- function __addDays(date, days) {
|
|
|
- var newDate = new Date(date.getTime());
|
|
|
- while (days > 0) {
|
|
|
- var leap = __isLeapYear(newDate.getFullYear());
|
|
|
- var currentMonth = newDate.getMonth();
|
|
|
- var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth];
|
|
|
- if (days > daysInCurrentMonth - newDate.getDate()) {
|
|
|
- days -= daysInCurrentMonth - newDate.getDate() + 1;
|
|
|
- newDate.setDate(1);
|
|
|
- if (currentMonth < 11) {
|
|
|
- newDate.setMonth(currentMonth + 1);
|
|
|
- } else {
|
|
|
- newDate.setMonth(0);
|
|
|
- newDate.setFullYear(newDate.getFullYear() + 1);
|
|
|
- }
|
|
|
- } else {
|
|
|
- newDate.setDate(newDate.getDate() + days);
|
|
|
- return newDate;
|
|
|
- }
|
|
|
- }
|
|
|
- return newDate;
|
|
|
- }
|
|
|
- function _strftime(s, maxsize, format, tm) {
|
|
|
- var tm_zone = HEAP32[(tm + 40) >> 2];
|
|
|
- var date = {
|
|
|
- tm_sec: HEAP32[tm >> 2],
|
|
|
- tm_min: HEAP32[(tm + 4) >> 2],
|
|
|
- tm_hour: HEAP32[(tm + 8) >> 2],
|
|
|
- tm_mday: HEAP32[(tm + 12) >> 2],
|
|
|
- tm_mon: HEAP32[(tm + 16) >> 2],
|
|
|
- tm_year: HEAP32[(tm + 20) >> 2],
|
|
|
- tm_wday: HEAP32[(tm + 24) >> 2],
|
|
|
- tm_yday: HEAP32[(tm + 28) >> 2],
|
|
|
- tm_isdst: HEAP32[(tm + 32) >> 2],
|
|
|
- tm_gmtoff: HEAP32[(tm + 36) >> 2],
|
|
|
- tm_zone: tm_zone ? UTF8ToString(tm_zone) : ''
|
|
|
- };
|
|
|
- var pattern = UTF8ToString(format);
|
|
|
- var EXPANSION_RULES_1 = {
|
|
|
- '%c': '%a %b %d %H:%M:%S %Y',
|
|
|
- '%D': '%m/%d/%y',
|
|
|
- '%F': '%Y-%m-%d',
|
|
|
- '%h': '%b',
|
|
|
- '%r': '%I:%M:%S %p',
|
|
|
- '%R': '%H:%M',
|
|
|
- '%T': '%H:%M:%S',
|
|
|
- '%x': '%m/%d/%y',
|
|
|
- '%X': '%H:%M:%S',
|
|
|
- '%Ec': '%c',
|
|
|
- '%EC': '%C',
|
|
|
- '%Ex': '%m/%d/%y',
|
|
|
- '%EX': '%H:%M:%S',
|
|
|
- '%Ey': '%y',
|
|
|
- '%EY': '%Y',
|
|
|
- '%Od': '%d',
|
|
|
- '%Oe': '%e',
|
|
|
- '%OH': '%H',
|
|
|
- '%OI': '%I',
|
|
|
- '%Om': '%m',
|
|
|
- '%OM': '%M',
|
|
|
- '%OS': '%S',
|
|
|
- '%Ou': '%u',
|
|
|
- '%OU': '%U',
|
|
|
- '%OV': '%V',
|
|
|
- '%Ow': '%w',
|
|
|
- '%OW': '%W',
|
|
|
- '%Oy': '%y'
|
|
|
- };
|
|
|
- for (var rule in EXPANSION_RULES_1) {
|
|
|
- pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_1[rule]);
|
|
|
- }
|
|
|
- var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
|
|
|
- var MONTHS = [
|
|
|
- 'January',
|
|
|
- 'February',
|
|
|
- 'March',
|
|
|
- 'April',
|
|
|
- 'May',
|
|
|
- 'June',
|
|
|
- 'July',
|
|
|
- 'August',
|
|
|
- 'September',
|
|
|
- 'October',
|
|
|
- 'November',
|
|
|
- 'December'
|
|
|
- ];
|
|
|
- function leadingSomething(value, digits, character) {
|
|
|
- var str = typeof value === 'number' ? value.toString() : value || '';
|
|
|
- while (str.length < digits) {
|
|
|
- str = character[0] + str;
|
|
|
- }
|
|
|
- return str;
|
|
|
- }
|
|
|
- function leadingNulls(value, digits) {
|
|
|
- return leadingSomething(value, digits, '0');
|
|
|
- }
|
|
|
- function compareByDay(date1, date2) {
|
|
|
- function sgn(value) {
|
|
|
- return value < 0 ? -1 : value > 0 ? 1 : 0;
|
|
|
- }
|
|
|
- var compare;
|
|
|
- if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
|
|
|
- if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
|
|
|
- compare = sgn(date1.getDate() - date2.getDate());
|
|
|
- }
|
|
|
- }
|
|
|
- return compare;
|
|
|
- }
|
|
|
- function getFirstWeekStartDate(janFourth) {
|
|
|
- switch (janFourth.getDay()) {
|
|
|
- case 0:
|
|
|
- return new Date(janFourth.getFullYear() - 1, 11, 29);
|
|
|
- case 1:
|
|
|
- return janFourth;
|
|
|
- case 2:
|
|
|
- return new Date(janFourth.getFullYear(), 0, 3);
|
|
|
- case 3:
|
|
|
- return new Date(janFourth.getFullYear(), 0, 2);
|
|
|
- case 4:
|
|
|
- return new Date(janFourth.getFullYear(), 0, 1);
|
|
|
- case 5:
|
|
|
- return new Date(janFourth.getFullYear() - 1, 11, 31);
|
|
|
- case 6:
|
|
|
- return new Date(janFourth.getFullYear() - 1, 11, 30);
|
|
|
- }
|
|
|
- }
|
|
|
- function getWeekBasedYear(date) {
|
|
|
- var thisDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday);
|
|
|
- var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
|
|
|
- var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
|
|
|
- var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
|
|
|
- var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
|
|
|
- if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
|
|
|
- if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
|
|
|
- return thisDate.getFullYear() + 1;
|
|
|
- } else {
|
|
|
- return thisDate.getFullYear();
|
|
|
- }
|
|
|
- } else {
|
|
|
- return thisDate.getFullYear() - 1;
|
|
|
- }
|
|
|
- }
|
|
|
- var EXPANSION_RULES_2 = {
|
|
|
- '%a': function (date) {
|
|
|
- return WEEKDAYS[date.tm_wday].substring(0, 3);
|
|
|
- },
|
|
|
- '%A': function (date) {
|
|
|
- return WEEKDAYS[date.tm_wday];
|
|
|
- },
|
|
|
- '%b': function (date) {
|
|
|
- return MONTHS[date.tm_mon].substring(0, 3);
|
|
|
- },
|
|
|
- '%B': function (date) {
|
|
|
- return MONTHS[date.tm_mon];
|
|
|
- },
|
|
|
- '%C': function (date) {
|
|
|
- var year = date.tm_year + 1900;
|
|
|
- return leadingNulls((year / 100) | 0, 2);
|
|
|
- },
|
|
|
- '%d': function (date) {
|
|
|
- return leadingNulls(date.tm_mday, 2);
|
|
|
- },
|
|
|
- '%e': function (date) {
|
|
|
- return leadingSomething(date.tm_mday, 2, ' ');
|
|
|
- },
|
|
|
- '%g': function (date) {
|
|
|
- return getWeekBasedYear(date).toString().substring(2);
|
|
|
- },
|
|
|
- '%G': function (date) {
|
|
|
- return getWeekBasedYear(date);
|
|
|
- },
|
|
|
- '%H': function (date) {
|
|
|
- return leadingNulls(date.tm_hour, 2);
|
|
|
- },
|
|
|
- '%I': function (date) {
|
|
|
- var twelveHour = date.tm_hour;
|
|
|
- if (twelveHour == 0) twelveHour = 12;
|
|
|
- else if (twelveHour > 12) twelveHour -= 12;
|
|
|
- return leadingNulls(twelveHour, 2);
|
|
|
- },
|
|
|
- '%j': function (date) {
|
|
|
- return leadingNulls(
|
|
|
- date.tm_mday + __arraySum(__isLeapYear(date.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon - 1),
|
|
|
- 3
|
|
|
- );
|
|
|
- },
|
|
|
- '%m': function (date) {
|
|
|
- return leadingNulls(date.tm_mon + 1, 2);
|
|
|
- },
|
|
|
- '%M': function (date) {
|
|
|
- return leadingNulls(date.tm_min, 2);
|
|
|
- },
|
|
|
- '%n': function () {
|
|
|
- return '\n';
|
|
|
- },
|
|
|
- '%p': function (date) {
|
|
|
- if (date.tm_hour >= 0 && date.tm_hour < 12) {
|
|
|
- return 'AM';
|
|
|
- } else {
|
|
|
- return 'PM';
|
|
|
- }
|
|
|
- },
|
|
|
- '%S': function (date) {
|
|
|
- return leadingNulls(date.tm_sec, 2);
|
|
|
- },
|
|
|
- '%t': function () {
|
|
|
- return '\t';
|
|
|
- },
|
|
|
- '%u': function (date) {
|
|
|
- return date.tm_wday || 7;
|
|
|
- },
|
|
|
- '%U': function (date) {
|
|
|
- var janFirst = new Date(date.tm_year + 1900, 0, 1);
|
|
|
- var firstSunday = janFirst.getDay() === 0 ? janFirst : __addDays(janFirst, 7 - janFirst.getDay());
|
|
|
- var endDate = new Date(date.tm_year + 1900, date.tm_mon, date.tm_mday);
|
|
|
- if (compareByDay(firstSunday, endDate) < 0) {
|
|
|
- var februaryFirstUntilEndMonth =
|
|
|
- __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth() - 1) - 31;
|
|
|
- var firstSundayUntilEndJanuary = 31 - firstSunday.getDate();
|
|
|
- var days = firstSundayUntilEndJanuary + februaryFirstUntilEndMonth + endDate.getDate();
|
|
|
- return leadingNulls(Math.ceil(days / 7), 2);
|
|
|
- }
|
|
|
- return compareByDay(firstSunday, janFirst) === 0 ? '01' : '00';
|
|
|
- },
|
|
|
- '%V': function (date) {
|
|
|
- var janFourthThisYear = new Date(date.tm_year + 1900, 0, 4);
|
|
|
- var janFourthNextYear = new Date(date.tm_year + 1901, 0, 4);
|
|
|
- var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
|
|
|
- var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
|
|
|
- var endDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday);
|
|
|
- if (compareByDay(endDate, firstWeekStartThisYear) < 0) {
|
|
|
- return '53';
|
|
|
- }
|
|
|
- if (compareByDay(firstWeekStartNextYear, endDate) <= 0) {
|
|
|
- return '01';
|
|
|
- }
|
|
|
- var daysDifference;
|
|
|
- if (firstWeekStartThisYear.getFullYear() < date.tm_year + 1900) {
|
|
|
- daysDifference = date.tm_yday + 32 - firstWeekStartThisYear.getDate();
|
|
|
- } else {
|
|
|
- daysDifference = date.tm_yday + 1 - firstWeekStartThisYear.getDate();
|
|
|
- }
|
|
|
- return leadingNulls(Math.ceil(daysDifference / 7), 2);
|
|
|
- },
|
|
|
- '%w': function (date) {
|
|
|
- return date.tm_wday;
|
|
|
- },
|
|
|
- '%W': function (date) {
|
|
|
- var janFirst = new Date(date.tm_year, 0, 1);
|
|
|
- var firstMonday =
|
|
|
- janFirst.getDay() === 1 ? janFirst : __addDays(janFirst, janFirst.getDay() === 0 ? 1 : 7 - janFirst.getDay() + 1);
|
|
|
- var endDate = new Date(date.tm_year + 1900, date.tm_mon, date.tm_mday);
|
|
|
- if (compareByDay(firstMonday, endDate) < 0) {
|
|
|
- var februaryFirstUntilEndMonth =
|
|
|
- __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth() - 1) - 31;
|
|
|
- var firstMondayUntilEndJanuary = 31 - firstMonday.getDate();
|
|
|
- var days = firstMondayUntilEndJanuary + februaryFirstUntilEndMonth + endDate.getDate();
|
|
|
- return leadingNulls(Math.ceil(days / 7), 2);
|
|
|
- }
|
|
|
- return compareByDay(firstMonday, janFirst) === 0 ? '01' : '00';
|
|
|
- },
|
|
|
- '%y': function (date) {
|
|
|
- return (date.tm_year + 1900).toString().substring(2);
|
|
|
- },
|
|
|
- '%Y': function (date) {
|
|
|
- return date.tm_year + 1900;
|
|
|
- },
|
|
|
- '%z': function (date) {
|
|
|
- var off = date.tm_gmtoff;
|
|
|
- var ahead = off >= 0;
|
|
|
- off = Math.abs(off) / 60;
|
|
|
- off = (off / 60) * 100 + (off % 60);
|
|
|
- return (ahead ? '+' : '-') + String('0000' + off).slice(-4);
|
|
|
- },
|
|
|
- '%Z': function (date) {
|
|
|
- return date.tm_zone;
|
|
|
- },
|
|
|
- '%%': function () {
|
|
|
- return '%';
|
|
|
- }
|
|
|
- };
|
|
|
- for (var rule in EXPANSION_RULES_2) {
|
|
|
- if (pattern.includes(rule)) {
|
|
|
- pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_2[rule](date));
|
|
|
- }
|
|
|
- }
|
|
|
- var bytes = intArrayFromString(pattern, false);
|
|
|
- if (bytes.length > maxsize) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- writeArrayToMemory(bytes, s);
|
|
|
- return bytes.length - 1;
|
|
|
- }
|
|
|
- function _strftime_l(s, maxsize, format, tm) {
|
|
|
- return _strftime(s, maxsize, format, tm);
|
|
|
- }
|
|
|
- InternalError = Module['InternalError'] = extendError(Error, 'InternalError');
|
|
|
- embind_init_charCodes();
|
|
|
- BindingError = Module['BindingError'] = extendError(Error, 'BindingError');
|
|
|
- init_ClassHandle();
|
|
|
- init_RegisteredPointer();
|
|
|
- init_embind();
|
|
|
- UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');
|
|
|
- init_emval();
|
|
|
- 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();
|
|
|
- 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;
|
|
|
- }
|
|
|
- var asmLibraryArg = {
|
|
|
- d: ___cxa_allocate_exception,
|
|
|
- e: ___cxa_throw,
|
|
|
- n: __embind_finalize_value_array,
|
|
|
- p: __embind_finalize_value_object,
|
|
|
- y: __embind_register_bigint,
|
|
|
- I: __embind_register_bool,
|
|
|
- h: __embind_register_class,
|
|
|
- g: __embind_register_class_constructor,
|
|
|
- c: __embind_register_class_function,
|
|
|
- r: __embind_register_class_property,
|
|
|
- H: __embind_register_emval,
|
|
|
- q: __embind_register_enum,
|
|
|
- i: __embind_register_enum_value,
|
|
|
- v: __embind_register_float,
|
|
|
- a: __embind_register_function,
|
|
|
- k: __embind_register_integer,
|
|
|
- j: __embind_register_memory_view,
|
|
|
- w: __embind_register_std_string,
|
|
|
- t: __embind_register_std_wstring,
|
|
|
- o: __embind_register_value_array,
|
|
|
- b: __embind_register_value_array_element,
|
|
|
- m: __embind_register_value_object,
|
|
|
- f: __embind_register_value_object_field,
|
|
|
- J: __embind_register_void,
|
|
|
- K: __emval_decref,
|
|
|
- L: __emval_incref,
|
|
|
- l: __emval_take_value,
|
|
|
- u: _abort,
|
|
|
- A: _emscripten_memcpy_big,
|
|
|
- s: _emscripten_resize_heap,
|
|
|
- C: _environ_get,
|
|
|
- D: _environ_sizes_get,
|
|
|
- G: _fd_close,
|
|
|
- E: _fd_read,
|
|
|
- x: _fd_seek,
|
|
|
- F: _fd_write,
|
|
|
- z: _setTempRet0,
|
|
|
- B: _strftime_l
|
|
|
- };
|
|
|
- var asm = createWasm();
|
|
|
- var ___wasm_call_ctors = (Module['___wasm_call_ctors'] = function () {
|
|
|
- return (___wasm_call_ctors = Module['___wasm_call_ctors'] = Module['asm']['N']).apply(null, arguments);
|
|
|
- });
|
|
|
- var _malloc = (Module['_malloc'] = function () {
|
|
|
- return (_malloc = Module['_malloc'] = Module['asm']['P']).apply(null, arguments);
|
|
|
- });
|
|
|
- var _free = (Module['_free'] = function () {
|
|
|
- return (_free = Module['_free'] = Module['asm']['Q']).apply(null, arguments);
|
|
|
- });
|
|
|
- var ___getTypeName = (Module['___getTypeName'] = function () {
|
|
|
- return (___getTypeName = Module['___getTypeName'] = Module['asm']['R']).apply(null, arguments);
|
|
|
- });
|
|
|
- var ___embind_register_native_and_builtin_types = (Module['___embind_register_native_and_builtin_types'] = function () {
|
|
|
- return (___embind_register_native_and_builtin_types = Module['___embind_register_native_and_builtin_types'] =
|
|
|
- Module['asm']['S']).apply(null, arguments);
|
|
|
- });
|
|
|
- var stackSave = (Module['stackSave'] = function () {
|
|
|
- return (stackSave = Module['stackSave'] = Module['asm']['T']).apply(null, arguments);
|
|
|
- });
|
|
|
- var stackRestore = (Module['stackRestore'] = function () {
|
|
|
- return (stackRestore = Module['stackRestore'] = Module['asm']['U']).apply(null, arguments);
|
|
|
- });
|
|
|
- var stackAlloc = (Module['stackAlloc'] = function () {
|
|
|
- return (stackAlloc = Module['stackAlloc'] = Module['asm']['V']).apply(null, arguments);
|
|
|
- });
|
|
|
- var dynCall_jiji = (Module['dynCall_jiji'] = function () {
|
|
|
- return (dynCall_jiji = Module['dynCall_jiji'] = Module['asm']['W']).apply(null, arguments);
|
|
|
- });
|
|
|
- var dynCall_iiiiij = (Module['dynCall_iiiiij'] = function () {
|
|
|
- return (dynCall_iiiiij = Module['dynCall_iiiiij'] = Module['asm']['X']).apply(null, arguments);
|
|
|
- });
|
|
|
- var dynCall_iiiiijj = (Module['dynCall_iiiiijj'] = function () {
|
|
|
- return (dynCall_iiiiijj = Module['dynCall_iiiiijj'] = Module['asm']['Y']).apply(null, arguments);
|
|
|
- });
|
|
|
- var dynCall_iiiiiijj = (Module['dynCall_iiiiiijj'] = function () {
|
|
|
- return (dynCall_iiiiiijj = Module['dynCall_iiiiiijj'] = Module['asm']['Z']).apply(null, arguments);
|
|
|
- });
|
|
|
- var dynCall_viijii = (Module['dynCall_viijii'] = function () {
|
|
|
- return (dynCall_viijii = Module['dynCall_viijii'] = Module['asm']['_']).apply(null, arguments);
|
|
|
- });
|
|
|
- Module['ccall'] = ccall;
|
|
|
- var calledRun;
|
|
|
- dependenciesFulfilled = function runCaller() {
|
|
|
- if (!calledRun) run();
|
|
|
- if (!calledRun) dependenciesFulfilled = runCaller;
|
|
|
- };
|
|
|
- function run(args) {
|
|
|
- args = args || arguments_;
|
|
|
- if (runDependencies > 0) {
|
|
|
- return;
|
|
|
- }
|
|
|
- preRun();
|
|
|
- if (runDependencies > 0) {
|
|
|
- return;
|
|
|
- }
|
|
|
- function doRun() {
|
|
|
- if (calledRun) return;
|
|
|
- calledRun = true;
|
|
|
- Module['calledRun'] = true;
|
|
|
- if (ABORT) return;
|
|
|
- initRuntime();
|
|
|
- readyPromiseResolve(Module);
|
|
|
- if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();
|
|
|
- postRun();
|
|
|
- }
|
|
|
- if (Module['setStatus']) {
|
|
|
- Module['setStatus']('Running...');
|
|
|
- setTimeout(function () {
|
|
|
- setTimeout(function () {
|
|
|
- Module['setStatus']('');
|
|
|
- }, 1);
|
|
|
- doRun();
|
|
|
- }, 1);
|
|
|
- } else {
|
|
|
- doRun();
|
|
|
- }
|
|
|
- }
|
|
|
- Module['run'] = run;
|
|
|
- if (Module['preInit']) {
|
|
|
- if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
|
|
|
- while (Module['preInit'].length > 0) {
|
|
|
- Module['preInit'].pop()();
|
|
|
- }
|
|
|
- }
|
|
|
- run();
|
|
|
- return Module.ready;
|
|
|
- };
|
|
|
-})();
|
|
|
-export default Module;
|
dufu1991
