From 41f912ef50398bc3900ac672289046ca89335864 Mon Sep 17 00:00:00 2001 From: Andrey Kolosov Date: Fri, 23 Aug 2019 19:15:44 +0300 Subject: [PATCH] mpqc --- src/mpqcmp/MpqCmp.jscc | 2724 +++++++++++++++++++++++++++++++++++ src/mpqcmp/MpqCmp.wasm | Bin 0 -> 356747 bytes src/mpqcmp/mpqcmp.worker.js | 114 ++ 3 files changed, 2838 insertions(+) create mode 100644 src/mpqcmp/MpqCmp.jscc create mode 100644 src/mpqcmp/MpqCmp.wasm create mode 100644 src/mpqcmp/mpqcmp.worker.js diff --git a/src/mpqcmp/MpqCmp.jscc b/src/mpqcmp/MpqCmp.jscc new file mode 100644 index 0000000..cc1906b --- /dev/null +++ b/src/mpqcmp/MpqCmp.jscc @@ -0,0 +1,2724 @@ + +var MpqCmp = (function() { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + return ( +function(MpqCmp) { + MpqCmp = MpqCmp || {}; + +// Copyright 2010 The Emscripten Authors. All rights reserved. +// Emscripten is available under two separate licenses, the MIT license and the +// University of Illinois/NCSA Open Source License. Both these licenses can be +// found in the LICENSE file. + +// The Module object: Our interface to the outside world. We import +// and export values on it. There are various ways Module can be used: +// 1. Not defined. We create it here +// 2. A function parameter, function(Module) { ..generated code.. } +// 3. pre-run appended it, var Module = {}; ..generated code.. +// 4. External script tag defines var Module. +// We need to check if Module already exists (e.g. case 3 above). +// Substitution will be replaced with actual code on later stage of the build, +// this way Closure Compiler will not mangle it (e.g. case 4. above). +// Note that if you want to run closure, and also to use Module +// after the generated code, you will need to define var Module = {}; +// before the code. Then that object will be used in the code, and you +// can continue to use Module afterwards as well. +var Module = typeof MpqCmp !== 'undefined' ? MpqCmp : {}; + +// --pre-jses are emitted after the Module integration code, so that they can +// refer to Module (if they choose; they can also define Module) + + +// Sometimes an existing Module object exists with properties +// meant to overwrite the default module functionality. Here +// we collect those properties and reapply _after_ we configure +// the current environment's defaults to avoid having to be so +// defensive during initialization. +var moduleOverrides = {}; +var key; +for (key in Module) { + if (Module.hasOwnProperty(key)) { + moduleOverrides[key] = Module[key]; + } +} + +Module['arguments'] = []; +Module['thisProgram'] = './this.program'; +Module['quit'] = function(status, toThrow) { + throw toThrow; +}; +Module['preRun'] = []; +Module['postRun'] = []; + +// Determine the runtime environment we are in. You can customize this by +// setting the ENVIRONMENT setting at compile time (see settings.js). + +var ENVIRONMENT_IS_WEB = false; +var ENVIRONMENT_IS_WORKER = false; +var ENVIRONMENT_IS_NODE = false; +var ENVIRONMENT_HAS_NODE = false; +var ENVIRONMENT_IS_SHELL = false; +ENVIRONMENT_IS_WEB = typeof window === 'object'; +ENVIRONMENT_IS_WORKER = typeof importScripts === 'function'; +// A web environment like Electron.js can have Node enabled, so we must +// distinguish between Node-enabled environments and Node environments per se. +// This will allow the former to do things like mount NODEFS. +// Extended check using process.versions fixes issue #8816. +// (Also makes redundant the original check that 'require' is a function.) +ENVIRONMENT_HAS_NODE = typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string'; +ENVIRONMENT_IS_NODE = ENVIRONMENT_HAS_NODE && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER; +ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + + + +// Three configurations we can be running in: +// 1) We could be the application main() thread running in the main JS UI thread. (ENVIRONMENT_IS_WORKER == false and ENVIRONMENT_IS_PTHREAD == false) +// 2) We could be the application main() thread proxied to worker. (with Emscripten -s PROXY_TO_WORKER=1) (ENVIRONMENT_IS_WORKER == true, ENVIRONMENT_IS_PTHREAD == false) +// 3) We could be an application pthread running in a worker. (ENVIRONMENT_IS_WORKER == true and ENVIRONMENT_IS_PTHREAD == true) + + + + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ''; +function locateFile(path) { + if (Module['locateFile']) { + return Module['locateFile'](path, scriptDirectory); + } else { + return scriptDirectory + path; + } +} + +// Hooks that are implemented differently in different runtime environments. +var read_, + readAsync, + readBinary, + setWindowTitle; + +if (ENVIRONMENT_IS_NODE) { + scriptDirectory = __dirname + '/'; + + // Expose functionality in the same simple way that the shells work + // Note that we pollute the global namespace here, otherwise we break in node + var nodeFS; + var nodePath; + + read_ = function shell_read(filename, binary) { + var ret; + if (!nodeFS) nodeFS = require('fs'); + if (!nodePath) nodePath = require('path'); + filename = nodePath['normalize'](filename); + ret = nodeFS['readFileSync'](filename); + return binary ? ret : ret.toString(); + }; + + readBinary = function readBinary(filename) { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; + }; + + if (process['argv'].length > 1) { + Module['thisProgram'] = process['argv'][1].replace(/\\/g, '/'); + } + + Module['arguments'] = process['argv'].slice(2); + + // MODULARIZE will export the module in the proper place outside, we don't need to export here + + process['on']('uncaughtException', function(ex) { + // suppress ExitStatus exceptions from showing an error + if (!(ex instanceof ExitStatus)) { + throw ex; + } + }); + // Currently node will swallow unhandled rejections, but this behavior is + // deprecated, and in the future it will exit with error status. + process['on']('unhandledRejection', abort); + + Module['quit'] = function(status) { + process['exit'](status); + }; + + Module['inspect'] = function () { return '[Emscripten Module object]'; }; +} else +if (ENVIRONMENT_IS_SHELL) { + + + if (typeof read != 'undefined') { + read_ = function shell_read(f) { + return read(f); + }; + } + + readBinary = function readBinary(f) { + var data; + if (typeof readbuffer === 'function') { + return new Uint8Array(readbuffer(f)); + } + data = read(f, 'binary'); + assert(typeof data === 'object'); + return data; + }; + + if (typeof scriptArgs != 'undefined') { + Module['arguments'] = scriptArgs; + } else if (typeof arguments != 'undefined') { + Module['arguments'] = arguments; + } + + if (typeof quit === 'function') { + Module['quit'] = function(status) { + quit(status); + } + } +} else +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled + scriptDirectory = self.location.href; + } else if (document.currentScript) { // web + scriptDirectory = document.currentScript.src; + } + // When MODULARIZE (and not _INSTANCE), this JS may be executed later, after document.currentScript + // is gone, so we saved it, and we use it here instead of any other info. + if (_scriptDir) { + scriptDirectory = _scriptDir; + } + // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. + // otherwise, slice off the final part of the url to find the script directory. + // if scriptDirectory does not contain a slash, lastIndexOf will return -1, + // and scriptDirectory will correctly be replaced with an empty string. + if (scriptDirectory.indexOf('blob:') !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/')+1); + } else { + scriptDirectory = ''; + } + + + read_ = function shell_read(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + }; + + if (ENVIRONMENT_IS_WORKER) { + readBinary = function readBinary(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.responseType = 'arraybuffer'; + xhr.send(null); + return new Uint8Array(xhr.response); + }; + } + + readAsync = function readAsync(url, onload, onerror) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = function xhr_onload() { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + }; + + setWindowTitle = function(title) { document.title = title }; +} else +{ +} + +// Set up the out() and err() hooks, which are how we can print to stdout or +// stderr, respectively. +// If the user provided Module.print or printErr, use that. Otherwise, +// console.log is checked first, as 'print' on the web will open a print dialogue +// printErr is preferable to console.warn (works better in shells) +// bind(console) is necessary to fix IE/Edge closed dev tools panel behavior. +var out = Module['print'] || (typeof console !== 'undefined' ? console.log.bind(console) : (typeof print !== 'undefined' ? print : null)); +var err = Module['printErr'] || (typeof printErr !== 'undefined' ? printErr : ((typeof console !== 'undefined' && console.warn.bind(console)) || out)); + +// Merge back in the overrides +for (key in moduleOverrides) { + if (moduleOverrides.hasOwnProperty(key)) { + Module[key] = moduleOverrides[key]; + } +} +// Free the object hierarchy contained in the overrides, this lets the GC +// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array. +moduleOverrides = undefined; + +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message + +// TODO remove when SDL2 is fixed; also add the above assertion + + + +// Copyright 2017 The Emscripten Authors. All rights reserved. +// Emscripten is available under two separate licenses, the MIT license and the +// University of Illinois/NCSA Open Source License. Both these licenses can be +// found in the LICENSE file. + +// {{PREAMBLE_ADDITIONS}} + +var STACK_ALIGN = 16; + + +function dynamicAlloc(size) { + var ret = HEAP32[DYNAMICTOP_PTR>>2]; + var end = (ret + size + 15) & -16; + if (end > _emscripten_get_heap_size()) { + abort(); + } + HEAP32[DYNAMICTOP_PTR>>2] = end; + return ret; +} + +function alignMemory(size, factor) { + if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default + return Math.ceil(size / factor) * factor; +} + +function getNativeTypeSize(type) { + switch (type) { + case 'i1': case 'i8': return 1; + case 'i16': return 2; + case 'i32': return 4; + case 'i64': return 8; + case 'float': return 4; + case 'double': return 8; + default: { + if (type[type.length-1] === '*') { + return 4; // A pointer + } else if (type[0] === 'i') { + var bits = parseInt(type.substr(1)); + assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type); + return bits / 8; + } else { + return 0; + } + } + } +} + +function warnOnce(text) { + if (!warnOnce.shown) warnOnce.shown = {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + err(text); + } +} + +var asm2wasmImports = { // special asm2wasm imports + "f64-rem": function(x, y) { + return x % y; + }, + "debugger": function() { + debugger; + } +}; + + + +var jsCallStartIndex = 1; +var functionPointers = new Array(0); + +// Wraps a JS function as a wasm function with a given signature. +// In the future, we may get a WebAssembly.Function constructor. Until then, +// we create a wasm module that takes the JS function as an import with a given +// signature, and re-exports that as a wasm function. +function convertJsFunctionToWasm(func, sig) { + + // The module is static, with the exception of the type section, which is + // generated based on the signature passed in. + var typeSection = [ + 0x01, // id: section, + 0x00, // length: 0 (placeholder) + 0x01, // count: 1 + 0x60, // form: func + ]; + var sigRet = sig.slice(0, 1); + var sigParam = sig.slice(1); + var typeCodes = { + 'i': 0x7f, // i32 + 'j': 0x7e, // i64 + 'f': 0x7d, // f32 + 'd': 0x7c, // f64 + }; + + // Parameters, length + signatures + typeSection.push(sigParam.length); + for (var i = 0; i < sigParam.length; ++i) { + typeSection.push(typeCodes[sigParam[i]]); + } + + // Return values, length + signatures + // With no multi-return in MVP, either 0 (void) or 1 (anything else) + if (sigRet == 'v') { + typeSection.push(0x00); + } else { + typeSection = typeSection.concat([0x01, typeCodes[sigRet]]); + } + + // Write the overall length of the type section back into the section header + // (excepting the 2 bytes for the section id and length) + typeSection[1] = typeSection.length - 2; + + // Rest of the module is static + var bytes = new Uint8Array([ + 0x00, 0x61, 0x73, 0x6d, // magic ("\0asm") + 0x01, 0x00, 0x00, 0x00, // version: 1 + ].concat(typeSection, [ + 0x02, 0x07, // import section + // (import "e" "f" (func 0 (type 0))) + 0x01, 0x01, 0x65, 0x01, 0x66, 0x00, 0x00, + 0x07, 0x05, // export section + // (export "f" (func 0 (type 0))) + 0x01, 0x01, 0x66, 0x00, 0x00, + ])); + + // We can compile this wasm module synchronously because it is very small. + // This accepts an import (at "e.f"), that it reroutes to an export (at "f") + var module = new WebAssembly.Module(bytes); + var instance = new WebAssembly.Instance(module, { + e: { + f: func + } + }); + var wrappedFunc = instance.exports.f; + return wrappedFunc; +} + +// Add a wasm function to the table. +function addFunctionWasm(func, sig) { + var table = wasmTable; + var ret = table.length; + + // Grow the table + try { + table.grow(1); + } catch (err) { + if (!err instanceof RangeError) { + throw err; + } + throw 'Unable to grow wasm table. Use a higher value for RESERVED_FUNCTION_POINTERS or set ALLOW_TABLE_GROWTH.'; + } + + // Insert new element + try { + // Attempting to call this with JS function will cause of table.set() to fail + table.set(ret, func); + } catch (err) { + if (!err instanceof TypeError) { + throw err; + } + assert(typeof sig !== 'undefined', 'Missing signature argument to addFunction'); + var wrapped = convertJsFunctionToWasm(func, sig); + table.set(ret, wrapped); + } + + return ret; +} + +function removeFunctionWasm(index) { + // TODO(sbc): Look into implementing this to allow re-using of table slots +} + +// 'sig' parameter is required for the llvm backend but only when func is not +// already a WebAssembly function. +function addFunction(func, sig) { + + + var base = 0; + for (var i = base; i < base + 0; i++) { + if (!functionPointers[i]) { + functionPointers[i] = func; + return jsCallStartIndex + i; + } + } + throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.'; + +} + +function removeFunction(index) { + + functionPointers[index-jsCallStartIndex] = null; +} + +var funcWrappers = {}; + +function getFuncWrapper(func, sig) { + if (!func) return; // on null pointer, return undefined + assert(sig); + if (!funcWrappers[sig]) { + funcWrappers[sig] = {}; + } + var sigCache = funcWrappers[sig]; + if (!sigCache[func]) { + // optimize away arguments usage in common cases + if (sig.length === 1) { + sigCache[func] = function dynCall_wrapper() { + return dynCall(sig, func); + }; + } else if (sig.length === 2) { + sigCache[func] = function dynCall_wrapper(arg) { + return dynCall(sig, func, [arg]); + }; + } else { + // general case + sigCache[func] = function dynCall_wrapper() { + return dynCall(sig, func, Array.prototype.slice.call(arguments)); + }; + } + } + return sigCache[func]; +} + + +function makeBigInt(low, high, unsigned) { + return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0)); +} + +function dynCall(sig, ptr, args) { + if (args && args.length) { + return Module['dynCall_' + sig].apply(null, [ptr].concat(args)); + } else { + return Module['dynCall_' + sig].call(null, ptr); + } +} + +var tempRet0 = 0; + +var setTempRet0 = function(value) { + tempRet0 = value; +}; + +var getTempRet0 = function() { + return tempRet0; +}; + + +var Runtime = { +}; + +// The address globals begin at. Very low in memory, for code size and optimization opportunities. +// Above 0 is static memory, starting with globals. +// Then the stack. +// Then 'dynamic' memory for sbrk. +var GLOBAL_BASE = 1024; + + + + +// === Preamble library stuff === + +// Documentation for the public APIs defined in this file must be updated in: +// site/source/docs/api_reference/preamble.js.rst +// A prebuilt local version of the documentation is available at: +// site/build/text/docs/api_reference/preamble.js.txt +// You can also build docs locally as HTML or other formats in site/ +// An online HTML version (which may be of a different version of Emscripten) +// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html + + + +if (typeof WebAssembly !== 'object') { + err('no native wasm support detected'); +} + + +// In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking. +// In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties) + +/** @type {function(number, number, string, boolean=)} */ +function setValue(ptr, value, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + switch(type) { + case 'i1': HEAP8[((ptr)>>0)]=value; break; + case 'i8': HEAP8[((ptr)>>0)]=value; break; + case 'i16': HEAP16[((ptr)>>1)]=value; break; + case 'i32': HEAP32[((ptr)>>2)]=value; break; + case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math_min((+(Math_floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break; + case 'float': HEAPF32[((ptr)>>2)]=value; break; + case 'double': HEAPF64[((ptr)>>3)]=value; break; + default: abort('invalid type for setValue: ' + type); + } +} + +/** @type {function(number, string, boolean=)} */ +function getValue(ptr, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + switch(type) { + case 'i1': return HEAP8[((ptr)>>0)]; + case 'i8': return HEAP8[((ptr)>>0)]; + case 'i16': return HEAP16[((ptr)>>1)]; + case 'i32': return HEAP32[((ptr)>>2)]; + case 'i64': return HEAP32[((ptr)>>2)]; + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return HEAPF64[((ptr)>>3)]; + default: abort('invalid type for getValue: ' + type); + } + return null; +} + + + + + +// Wasm globals + +var wasmMemory; + +// Potentially used for direct table calls. +var wasmTable; + + +//======================================== +// Runtime essentials +//======================================== + +// whether we are quitting the application. no code should run after this. +// set in exit() and abort() +var ABORT = false; + +// set by exit() and abort(). Passed to 'onExit' handler. +// NOTE: This is also used as the process return code code in shell environments +// but only when noExitRuntime is false. +var EXITSTATUS = 0; + +/** @type {function(*, string=)} */ +function assert(condition, text) { + if (!condition) { + abort('Assertion failed: ' + text); + } +} + +// Returns the C function with a specified identifier (for C++, you need to do manual name mangling) +function getCFunc(ident) { + var func = Module['_' + ident]; // closure exported function + assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported'); + return func; +} + +// C calling interface. +function ccall(ident, returnType, argTypes, args, opts) { + // For fast lookup of conversion functions + var toC = { + 'string': function(str) { + var ret = 0; + if (str !== null && str !== undefined && str !== 0) { // null string + // at most 4 bytes per UTF-8 code point, +1 for the trailing '\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); + ret = convertReturnValue(ret); + if (stack !== 0) stackRestore(stack); + return ret; +} + +function cwrap(ident, returnType, argTypes, opts) { + argTypes = argTypes || []; + // When the function takes numbers and returns a number, we can just return + // the original function + var numericArgs = argTypes.every(function(type){ return type === 'number'}); + var numericRet = returnType !== 'string'; + if (numericRet && numericArgs && !opts) { + return getCFunc(ident); + } + return function() { + return ccall(ident, returnType, argTypes, arguments, opts); + } +} + +var ALLOC_NORMAL = 0; // Tries to use _malloc() +var ALLOC_STACK = 1; // Lives for the duration of the current function call +var ALLOC_DYNAMIC = 2; // Cannot be freed except through sbrk +var ALLOC_NONE = 3; // Do not allocate + +// allocate(): This is for internal use. You can use it yourself as well, but the interface +// is a little tricky (see docs right below). The reason is that it is optimized +// for multiple syntaxes to save space in generated code. So you should +// normally not use allocate(), and instead allocate memory using _malloc(), +// initialize it with setValue(), and so forth. +// @slab: An array of data, or a number. If a number, then the size of the block to allocate, +// in *bytes* (note that this is sometimes confusing: the next parameter does not +// affect this!) +// @types: Either an array of types, one for each byte (or 0 if no type at that position), +// or a single type which is used for the entire block. This only matters if there +// is initial data - if @slab is a number, then this does not matter at all and is +// ignored. +// @allocator: How to allocate memory, see ALLOC_* +/** @type {function((TypedArray|Array|number), string, number, number=)} */ +function allocate(slab, types, allocator, ptr) { + var zeroinit, size; + if (typeof slab === 'number') { + zeroinit = true; + size = slab; + } else { + zeroinit = false; + size = slab.length; + } + + var singleType = typeof types === 'string' ? types : null; + + var ret; + if (allocator == ALLOC_NONE) { + ret = ptr; + } else { + ret = [_malloc, + stackAlloc, + dynamicAlloc][allocator](Math.max(size, singleType ? 1 : types.length)); + } + + if (zeroinit) { + var stop; + ptr = ret; + assert((ret & 3) == 0); + stop = ret + (size & ~3); + for (; ptr < stop; ptr += 4) { + HEAP32[((ptr)>>2)]=0; + } + stop = ret + size; + while (ptr < stop) { + HEAP8[((ptr++)>>0)]=0; + } + return ret; + } + + if (singleType === 'i8') { + if (slab.subarray || slab.slice) { + HEAPU8.set(/** @type {!Uint8Array} */ (slab), ret); + } else { + HEAPU8.set(new Uint8Array(slab), ret); + } + return ret; + } + + var i = 0, type, typeSize, previousType; + while (i < size) { + var curr = slab[i]; + + type = singleType || types[i]; + if (type === 0) { + i++; + continue; + } + + if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later + + setValue(ret+i, curr, type); + + // no need to look up size unless type changes, so cache it + if (previousType !== type) { + typeSize = getNativeTypeSize(type); + previousType = type; + } + i += typeSize; + } + + return ret; +} + +// Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready +function getMemory(size) { + if (!runtimeInitialized) return dynamicAlloc(size); + return _malloc(size); +} + + + + +/** @type {function(number, number=)} */ +function Pointer_stringify(ptr, length) { + abort("this function has been removed - you should use UTF8ToString(ptr, maxBytesToRead) instead!"); +} + +// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns +// a copy of that string as a Javascript String object. + +function AsciiToString(ptr) { + var str = ''; + while (1) { + var ch = HEAPU8[((ptr++)>>0)]; + if (!ch) return str; + str += String.fromCharCode(ch); + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP. + +function stringToAscii(str, outPtr) { + return writeAsciiToMemory(str, outPtr, false); +} + + +// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns +// a copy of that string as a Javascript String object. + +var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined; + +/** + * @param {number} idx + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ArrayToString(u8Array, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity) + while (u8Array[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) { + return UTF8Decoder.decode(u8Array.subarray(idx, endPtr)); + } else { + var str = ''; + // If building with TextDecoder, we have already computed the string length above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = u8Array[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = u8Array[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = u8Array[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (u8Array[idx++] & 63); + } + + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + } + return str; +} + +// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a +// copy of that string as a Javascript String object. +// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit +// this parameter to scan the string until the first \0 byte. If maxBytesToRead is +// passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the +// middle, then the string will cut short at that byte index (i.e. maxBytesToRead will +// not produce a string of exact length [ptr, ptr+maxBytesToRead[) +// N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may +// throw JS JIT optimizations off, so it is worth to consider consistently using one +// style or the other. +/** + * @param {number} ptr + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ''; +} + +// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx', +// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP. +// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outU8Array: the array to copy to. Each index in this array is assumed to be one 8-byte element. +// outIdx: The starting offset in the array to begin the copying. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. +// This count should include the null terminator, +// i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else. +// maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes. + return 0; + + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + outU8Array[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + outU8Array[outIdx++] = 0xC0 | (u >> 6); + outU8Array[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + outU8Array[outIdx++] = 0xE0 | (u >> 12); + outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); + outU8Array[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + outU8Array[outIdx++] = 0xF0 | (u >> 18); + outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); + outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); + outU8Array[outIdx++] = 0x80 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + outU8Array[outIdx] = 0; + return outIdx - startIdx; +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP. +// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF8(str, outPtr, maxBytesToWrite) { + return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite); +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte. +function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF); + if (u <= 0x7F) ++len; + else if (u <= 0x7FF) len += 2; + else if (u <= 0xFFFF) len += 3; + else len += 4; + } + return len; +} + + +// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns +// a copy of that string as a Javascript String object. + +var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined; +function UTF16ToString(ptr) { + var endPtr = ptr; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + var idx = endPtr >> 1; + while (HEAP16[idx]) ++idx; + endPtr = idx << 1; + + if (endPtr - ptr > 32 && UTF16Decoder) { + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + } else { + var i = 0; + + var str = ''; + while (1) { + var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; + if (codeUnit == 0) return str; + ++i; + // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP. +// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outPtr: Byte address in Emscripten HEAP where to write the string to. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null +// terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else. +// maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF16(str, outPtr, maxBytesToWrite) { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + HEAP16[((outPtr)>>1)]=codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr)>>1)]=0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF16(str) { + return str.length*2; +} + +function UTF32ToString(ptr) { + var i = 0; + + var str = ''; + while (1) { + var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; + if (utf32 == 0) + return str; + ++i; + // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + if (utf32 >= 0x10000) { + var ch = utf32 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } else { + str += String.fromCharCode(utf32); + } + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP. +// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outPtr: Byte address in Emscripten HEAP where to write the string to. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null +// terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else. +// maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF32(str, outPtr, maxBytesToWrite) { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); + } + HEAP32[((outPtr)>>2)]=codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr)>>2)]=0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. + len += 4; + } + + return len; +} + +// Allocate heap space for a JS string, and write it there. +// It is the responsibility of the caller to free() that memory. +function allocateUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Allocate stack space for a JS string, and write it there. +function allocateUTF8OnStack(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = stackAlloc(size); + stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Deprecated: This function should not be called because it is unsafe and does not provide +// a maximum length limit of how many bytes it is allowed to write. Prefer calling the +// function stringToUTF8Array() instead, which takes in a maximum length that can be used +// to be secure from out of bounds writes. +/** @deprecated */ +function writeStringToMemory(string, buffer, dontAddNull) { + warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!'); + + var /** @type {number} */ lastChar, /** @type {number} */ end; + if (dontAddNull) { + // stringToUTF8Array always appends null. If we don't want to do that, remember the + // character that existed at the location where the null will be placed, and restore + // that after the write (below). + end = buffer + lengthBytesUTF8(string); + lastChar = HEAP8[end]; + } + stringToUTF8(string, buffer, Infinity); + if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character. +} + +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); + } + // Null-terminate the pointer to the HEAP. + if (!dontAddNull) HEAP8[((buffer)>>0)]=0; +} + + + + + +function demangle(func) { + return func; +} + +function demangleAll(text) { + var regex = + /__Z[\w\d_]+/g; + return text.replace(regex, + function(x) { + var y = demangle(x); + return x === y ? x : (y + ' [' + x + ']'); + }); +} + +function jsStackTrace() { + var err = new Error(); + if (!err.stack) { + // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown, + // so try that as a special-case. + try { + throw new Error(0); + } catch(e) { + err = e; + } + if (!err.stack) { + return '(no stack trace available)'; + } + } + return err.stack.toString(); +} + +function stackTrace() { + var js = jsStackTrace(); + if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace'](); + return demangleAll(js); +} + + + +// Memory management + +var PAGE_SIZE = 16384; +var WASM_PAGE_SIZE = 65536; +var ASMJS_PAGE_SIZE = 16777216; + +function alignUp(x, multiple) { + if (x % multiple > 0) { + x += multiple - (x % multiple); + } + return x; +} + +var HEAP, +/** @type {ArrayBuffer} */ + buffer, +/** @type {Int8Array} */ + HEAP8, +/** @type {Uint8Array} */ + HEAPU8, +/** @type {Int16Array} */ + HEAP16, +/** @type {Uint16Array} */ + HEAPU16, +/** @type {Int32Array} */ + HEAP32, +/** @type {Uint32Array} */ + HEAPU32, +/** @type {Float32Array} */ + HEAPF32, +/** @type {Float64Array} */ + HEAPF64; + +function updateGlobalBufferViews() { + Module['HEAP8'] = HEAP8 = new Int8Array(buffer); + Module['HEAP16'] = HEAP16 = new Int16Array(buffer); + Module['HEAP32'] = HEAP32 = new Int32Array(buffer); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(buffer); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(buffer); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(buffer); + Module['HEAPF32'] = HEAPF32 = new Float32Array(buffer); + Module['HEAPF64'] = HEAPF64 = new Float64Array(buffer); +} + + +var STATIC_BASE = 1024, + STACK_BASE = 127296, + STACKTOP = STACK_BASE, + STACK_MAX = 5370176, + DYNAMIC_BASE = 5370176, + DYNAMICTOP_PTR = 127264; + + + + +var TOTAL_STACK = 5242880; + +var INITIAL_TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 134217728; +if (INITIAL_TOTAL_MEMORY < TOTAL_STACK) err('TOTAL_MEMORY should be larger than TOTAL_STACK, was ' + INITIAL_TOTAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')'); + +// Initialize the runtime's memory + + + + + + + if (Module['wasmMemory']) { + wasmMemory = Module['wasmMemory']; + } else { + wasmMemory = new WebAssembly.Memory({ + 'initial': INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE + }); + } + + +if (wasmMemory) { + buffer = wasmMemory.buffer; +} + +// If the user provides an incorrect length, just use that length instead rather than providing the user to +// specifically provide the memory length with Module['TOTAL_MEMORY']. +INITIAL_TOTAL_MEMORY = buffer.byteLength; +updateGlobalBufferViews(); + +HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE; + + + + + + +// Endianness check (note: assumes compiler arch was little-endian) + +function callRuntimeCallbacks(callbacks) { + while(callbacks.length > 0) { + var callback = callbacks.shift(); + if (typeof callback == 'function') { + callback(); + continue; + } + var func = callback.func; + if (typeof func === 'number') { + if (callback.arg === undefined) { + Module['dynCall_v'](func); + } else { + Module['dynCall_vi'](func, callback.arg); + } + } else { + func(callback.arg === undefined ? null : callback.arg); + } + } +} + +var __ATPRERUN__ = []; // functions called before the runtime is initialized +var __ATINIT__ = []; // functions called during startup +var __ATMAIN__ = []; // functions called when main() is to be run +var __ATEXIT__ = []; // functions called during shutdown +var __ATPOSTRUN__ = []; // functions called after the main() is called + +var runtimeInitialized = false; +var runtimeExited = false; + + +function preRun() { + // compatibility - merge in anything from Module['preRun'] at this time + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + while (Module['preRun'].length) { + addOnPreRun(Module['preRun'].shift()); + } + } + callRuntimeCallbacks(__ATPRERUN__); +} + +function initRuntime() { + runtimeInitialized = true; + + callRuntimeCallbacks(__ATINIT__); +} + +function preMain() { + + callRuntimeCallbacks(__ATMAIN__); +} + +function exitRuntime() { + runtimeExited = true; +} + +function postRun() { + // compatibility - merge in anything from Module['postRun'] at this time + if (Module['postRun']) { + if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; + while (Module['postRun'].length) { + addOnPostRun(Module['postRun'].shift()); + } + } + callRuntimeCallbacks(__ATPOSTRUN__); +} + +function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); +} + +function addOnInit(cb) { + __ATINIT__.unshift(cb); +} + +function addOnPreMain(cb) { + __ATMAIN__.unshift(cb); +} + +function addOnExit(cb) { +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +function unSign(value, bits, ignore) { + if (value >= 0) { + return value; + } + return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts + : Math.pow(2, bits) + value; +} +function reSign(value, bits, ignore) { + if (value <= 0) { + return value; + } + var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32 + : Math.pow(2, bits-1); + if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that + // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors + // TODO: In i64 mode 1, resign the two parts separately and safely + value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts + } + return value; +} + + + +var Math_abs = Math.abs; +var Math_cos = Math.cos; +var Math_sin = Math.sin; +var Math_tan = Math.tan; +var Math_acos = Math.acos; +var Math_asin = Math.asin; +var Math_atan = Math.atan; +var Math_atan2 = Math.atan2; +var Math_exp = Math.exp; +var Math_log = Math.log; +var Math_sqrt = Math.sqrt; +var Math_ceil = Math.ceil; +var Math_floor = Math.floor; +var Math_pow = Math.pow; +var Math_imul = Math.imul; +var Math_fround = Math.fround; +var Math_round = Math.round; +var Math_min = Math.min; +var Math_max = Math.max; +var Math_clz32 = Math.clz32; +var Math_trunc = Math.trunc; + + + +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; +var runDependencyWatcher = null; +var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled + +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(); // can add another dependenciesFulfilled + } + } +} + +Module["preloadedImages"] = {}; // maps url to image data +Module["preloadedAudios"] = {}; // maps url to audio data + + +var memoryInitializer = null; + + + + + + +// Copyright 2017 The Emscripten Authors. All rights reserved. +// Emscripten is available under two separate licenses, the MIT license and the +// University of Illinois/NCSA Open Source License. Both these licenses can be +// found in the LICENSE file. + +// Prefix of data URIs emitted by SINGLE_FILE and related options. +var dataURIPrefix = 'data:application/octet-stream;base64,'; + +// Indicates whether filename is a base64 data URI. +function isDataURI(filename) { + return String.prototype.startsWith ? + filename.startsWith(dataURIPrefix) : + filename.indexOf(dataURIPrefix) === 0; +} + + + + +var wasmBinaryFile = 'MpqCmp.wasm'; +if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); +} + +function getBinary() { + try { + if (Module['wasmBinary']) { + return new Uint8Array(Module['wasmBinary']); + } + if (readBinary) { + return readBinary(wasmBinaryFile); + } else { + throw "both async and sync fetching of the wasm failed"; + } + } + catch (err) { + abort(err); + } +} + +function getBinaryPromise() { + // if we don't have the binary yet, and have the Fetch api, use that + // in some environments, like Electron's render process, Fetch api may be present, but have a different context than expected, let's only use it on the Web + if (!Module['wasmBinary'] && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && 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(); + }); + } + // Otherwise, getBinary should be able to get it synchronously + return new Promise(function(resolve, reject) { + resolve(getBinary()); + }); +} + + + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +function createWasm(env) { + + // prepare imports + var info = { + 'env': env + , + 'global': { + 'NaN': NaN, + 'Infinity': Infinity + }, + 'global.Math': Math, + 'asm2wasm': asm2wasmImports + }; + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + function receiveInstance(instance, module) { + var exports = instance.exports; + Module['asm'] = exports; + removeRunDependency('wasm-instantiate'); + } + addRunDependency('wasm-instantiate'); + + + function receiveInstantiatedSource(output) { + // 'output' is a WebAssemblyInstantiatedSource object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above USE_PTHREADS-enabled path. + receiveInstance(output['instance']); + } + + + function instantiateArrayBuffer(receiver) { + return getBinaryPromise().then(function(binary) { + return WebAssembly.instantiate(binary, info); + }).then(receiver, function(reason) { + err('failed to asynchronously prepare wasm: ' + reason); + abort(reason); + }); + } + + // Prefer streaming instantiation if available. + function instantiateAsync() { + if (!Module['wasmBinary'] && + typeof WebAssembly.instantiateStreaming === 'function' && + !isDataURI(wasmBinaryFile) && + typeof fetch === 'function') { + fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function (response) { + return WebAssembly.instantiateStreaming(response, info) + .then(receiveInstantiatedSource, function(reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err('wasm streaming compile failed: ' + reason); + err('falling back to ArrayBuffer instantiation'); + instantiateArrayBuffer(receiveInstantiatedSource); + }); + }); + } else { + return instantiateArrayBuffer(receiveInstantiatedSource); + } + } + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel + // to any other async startup actions they are performing. + if (Module['instantiateWasm']) { + try { + var exports = Module['instantiateWasm'](info, receiveInstance); + return exports; + } catch(e) { + err('Module.instantiateWasm callback failed with error: ' + e); + return false; + } + } + + instantiateAsync(); + return {}; // no exports yet; we'll fill them in later +} + +// Provide an "asm.js function" for the application, called to "link" the asm.js module. We instantiate +// the wasm module at that time, and it receives imports and provides exports and so forth, the app +// doesn't need to care that it is wasm or asm.js. + +Module['asm'] = function(global, env, providedBuffer) { + // memory was already allocated (so js could use the buffer) + env['memory'] = wasmMemory + ; + // import table + env['table'] = wasmTable = new WebAssembly.Table({ + 'initial': 402, + 'maximum': 402, + 'element': 'anyfunc' + }); + // With the wasm backend __memory_base and __table_base and only needed for + // relocatable output. + env['__memory_base'] = 1024; // tell the memory segments where to place themselves + // table starts at 0 by default (even in dynamic linking, for the main module) + env['__table_base'] = 0; + + var exports = createWasm(env); + return exports; +}; + +// Globals used by JS i64 conversions +var tempDouble; +var tempI64; + +// === Body === + +var ASM_CONSTS = []; + +function _do_error(err){ var end = HEAPU8.indexOf( 0, err ); var text = String.fromCharCode.apply(null, HEAPU8.subarray( err, end )); self.DApi.exit_error( text ); } +function _do_progress(done,total){ self.DApi.progress(done, total); } +function _get_file_contents(ptr,offset,size){ self.DApi.get_file_contents(HEAPU8.subarray(ptr, ptr + size), offset); } +function _put_file_contents(ptr,offset,size){ self.DApi.put_file_contents(HEAPU8.subarray(ptr, ptr + size), offset); } +function _put_file_size(size){ self.DApi.put_file_size(size); } + + + +// STATICTOP = STATIC_BASE + 126272; +/* global initializers */ /*__ATINIT__.push();*/ + + + + + + + + +/* no memory initializer */ +var tempDoublePtr = 127280 + +function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much + HEAP8[tempDoublePtr] = HEAP8[ptr]; + HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; + HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; + HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; +} + +function copyTempDouble(ptr) { + HEAP8[tempDoublePtr] = HEAP8[ptr]; + HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; + HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; + HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; + HEAP8[tempDoublePtr+4] = HEAP8[ptr+4]; + HEAP8[tempDoublePtr+5] = HEAP8[ptr+5]; + HEAP8[tempDoublePtr+6] = HEAP8[ptr+6]; + HEAP8[tempDoublePtr+7] = HEAP8[ptr+7]; +} + +// {{PRE_LIBRARY}} + + + function ___assert_fail(condition, filename, line, func) { + abort('Assertion failed: ' + UTF8ToString(condition) + ', at: ' + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']); + } + + function ___cxa_allocate_exception(size) { + return _malloc(size); + } + + + var ___exception_infos={}; + + var ___exception_caught= []; + + function ___exception_addRef(ptr) { + if (!ptr) return; + var info = ___exception_infos[ptr]; + info.refcount++; + } + + function ___exception_deAdjust(adjusted) { + if (!adjusted || ___exception_infos[adjusted]) return adjusted; + for (var key in ___exception_infos) { + var ptr = +key; // the iteration key is a string, and if we throw this, it must be an integer as that is what we look for + var adj = ___exception_infos[ptr].adjusted; + var len = adj.length; + for (var i = 0; i < len; i++) { + if (adj[i] === adjusted) { + return ptr; + } + } + } + return adjusted; + }function ___cxa_begin_catch(ptr) { + var info = ___exception_infos[ptr]; + if (info && !info.caught) { + info.caught = true; + __ZSt18uncaught_exceptionv.uncaught_exceptions--; + } + if (info) info.rethrown = false; + ___exception_caught.push(ptr); + ___exception_addRef(___exception_deAdjust(ptr)); + return ptr; + } + + + var ___exception_last=0; + + + function ___cxa_free_exception(ptr) { + try { + return _free(ptr); + } catch(e) { + } + }function ___exception_decRef(ptr) { + if (!ptr) return; + var info = ___exception_infos[ptr]; + info.refcount--; + // A rethrown exception can reach refcount 0; it must not be discarded + // Its next handler will clear the rethrown flag and addRef it, prior to + // final decRef and destruction here + if (info.refcount === 0 && !info.rethrown) { + if (info.destructor) { + Module['dynCall_vi'](info.destructor, ptr); + } + delete ___exception_infos[ptr]; + ___cxa_free_exception(ptr); + } + } + + function ___cxa_end_catch() { + // Clear state flag. + _setThrew(0); + // Call destructor if one is registered then clear it. + var ptr = ___exception_caught.pop(); + if (ptr) { + ___exception_decRef(___exception_deAdjust(ptr)); + ___exception_last = 0; // XXX in decRef? + } + } + + + + function ___resumeException(ptr) { + if (!___exception_last) { ___exception_last = ptr; } + throw ptr; + }function ___cxa_find_matching_catch() { + var thrown = ___exception_last; + if (!thrown) { + // just pass through the null ptr + return ((setTempRet0(0),0)|0); + } + var info = ___exception_infos[thrown]; + var throwntype = info.type; + if (!throwntype) { + // just pass through the thrown ptr + return ((setTempRet0(0),thrown)|0); + } + var typeArray = Array.prototype.slice.call(arguments); + + var pointer = ___cxa_is_pointer_type(throwntype); + // can_catch receives a **, add indirection + var buffer = 127248; + HEAP32[((buffer)>>2)]=thrown; + thrown = buffer; + // The different catch blocks are denoted by different types. + // Due to inheritance, those types may not precisely match the + // type of the thrown object. Find one which matches, and + // return the type of the catch block which should be called. + for (var i = 0; i < typeArray.length; i++) { + if (typeArray[i] && ___cxa_can_catch(typeArray[i], throwntype, thrown)) { + thrown = HEAP32[((thrown)>>2)]; // undo indirection + info.adjusted.push(thrown); + return ((setTempRet0(typeArray[i]),thrown)|0); + } + } + // Shouldn't happen unless we have bogus data in typeArray + // or encounter a type for which emscripten doesn't have suitable + // typeinfo defined. Best-efforts match just in case. + thrown = HEAP32[((thrown)>>2)]; // undo indirection + return ((setTempRet0(throwntype),thrown)|0); + } + Module["___cxa_find_matching_catch"] = ___cxa_find_matching_catch;function ___cxa_find_matching_catch_2(a0,a1 + /*``*/) { + return ___cxa_find_matching_catch(a0,a1); + } + + function ___cxa_find_matching_catch_3(a0,a1,a2 + /*``*/) { + return ___cxa_find_matching_catch(a0,a1,a2); + } + + + function ___cxa_pure_virtual() { + ABORT = true; + throw 'Pure virtual function called!'; + } + + function ___cxa_throw(ptr, type, destructor) { + ___exception_infos[ptr] = { + ptr: ptr, + adjusted: [ptr], + type: type, + destructor: destructor, + refcount: 0, + caught: false, + rethrown: false + }; + ___exception_last = ptr; + if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) { + __ZSt18uncaught_exceptionv.uncaught_exceptions = 1; + } else { + __ZSt18uncaught_exceptionv.uncaught_exceptions++; + } + throw ptr; + } + + function ___cxa_uncaught_exceptions() { + return __ZSt18uncaught_exceptionv.uncaught_exceptions; + } + + function ___gxx_personality_v0() { + } + + + + + var PATH={splitPath:function (filename) { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + },normalizeArray:function (parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + 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 the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift('..'); + } + } + return parts; + },normalize:function (path) { + var isAbsolute = path.charAt(0) === '/', + trailingSlash = path.substr(-1) === '/'; + // Normalize the path + 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) { + // No dirname whatsoever + return '.'; + } + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + },basename:function (path) { + // EMSCRIPTEN return '/'' for '/', not an empty string + if (path === '/') return '/'; + 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); + }};var SYSCALLS={buffers:[null,[],[]],printChar:function (stream, curr) { + var buffer = SYSCALLS.buffers[stream]; + if (curr === 0 || curr === 10) { + (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0)); + buffer.length = 0; + } else { + buffer.push(curr); + } + },varargs:0,get:function (varargs) { + SYSCALLS.varargs += 4; + var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)]; + return ret; + },getStr:function () { + var ret = UTF8ToString(SYSCALLS.get()); + return ret; + },get64:function () { + var low = SYSCALLS.get(), high = SYSCALLS.get(); + return low; + },getZero:function () { + SYSCALLS.get(); + }};function ___syscall140(which, varargs) {SYSCALLS.varargs = varargs; + try { + // llseek + var stream = SYSCALLS.getStreamFromFD(), offset_high = SYSCALLS.get(), offset_low = SYSCALLS.get(), result = SYSCALLS.get(), whence = SYSCALLS.get(); + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } + } + + + function flush_NO_FILESYSTEM() { + // flush anything remaining in the buffers during shutdown + var fflush = Module["_fflush"]; + if (fflush) fflush(0); + var buffers = SYSCALLS.buffers; + if (buffers[1].length) SYSCALLS.printChar(1, 10); + if (buffers[2].length) SYSCALLS.printChar(2, 10); + }function ___syscall146(which, varargs) {SYSCALLS.varargs = varargs; + try { + // writev + // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0 + var stream = SYSCALLS.get(), iov = SYSCALLS.get(), iovcnt = SYSCALLS.get(); + 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)]; + for (var j = 0; j < len; j++) { + SYSCALLS.printChar(stream, HEAPU8[ptr+j]); + } + ret += len; + } + return ret; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } + } + + function ___syscall54(which, varargs) {SYSCALLS.varargs = varargs; + try { + // ioctl + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } + } + + function ___syscall6(which, varargs) {SYSCALLS.varargs = varargs; + try { + // close + var stream = SYSCALLS.getStreamFromFD(); + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } + } + + function _abort() { + Module['abort'](); + } + + function _emscripten_get_heap_size() { + return HEAP8.length; + } + + + + + function _llvm_exp2_f32(x) { + return Math.pow(2, x); + }function _llvm_exp2_f64(a0 + /*``*/) { + return _llvm_exp2_f32(a0); + } + + function _llvm_trap() { + abort('trap!'); + } + + + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.set(HEAPU8.subarray(src, src+num), dest); + } + + + + + + + + + function ___setErrNo(value) { + if (Module['___errno_location']) HEAP32[((Module['___errno_location']())>>2)]=value; + return value; + } + + + function abortOnCannotGrowMemory(requestedSize) { + abort('OOM'); + } + + function emscripten_realloc_buffer(size) { + var PAGE_MULTIPLE = 65536; + size = alignUp(size, PAGE_MULTIPLE); // round up to wasm page size + var oldSize = buffer.byteLength; + // native wasm support + // note that this is *not* threadsafe. multiple threads can call .grow(), and each + // presents a delta, so in theory we may over-allocate here (e.g. if two threads + // ask to grow from 256MB to 512MB, we get 2 requests to add +256MB, and may end + // up growing to 768MB (even though we may have been able to make do with 512MB). + // TODO: consider decreasing the step sizes in emscripten_resize_heap + try { + var result = wasmMemory.grow((size - oldSize) / 65536); // .grow() takes a delta compared to the previous size + if (result !== (-1 | 0)) { + // success in native wasm memory growth, get the buffer from the memory + buffer = wasmMemory.buffer; + return true; + } else { + return false; + } + } catch(e) { + return false; + } + }function _emscripten_resize_heap(requestedSize) { + var oldSize = _emscripten_get_heap_size(); + // With pthreads, races can happen (another thread might increase the size in between), so return a failure, and let the caller retry. + + + var PAGE_MULTIPLE = 65536; + var LIMIT = 2147483648 - PAGE_MULTIPLE; // We can do one page short of 2GB as theoretical maximum. + + if (requestedSize > LIMIT) { + return false; + } + + var MIN_TOTAL_MEMORY = 16777216; + var newSize = Math.max(oldSize, MIN_TOTAL_MEMORY); // So the loop below will not be infinite, and minimum asm.js memory size is 16MB. + + // TODO: see realloc_buffer - for PTHREADS we may want to decrease these jumps + while (newSize < requestedSize) { // Keep incrementing the heap size as long as it's less than what is requested. + if (newSize <= 536870912) { + newSize = alignUp(2 * newSize, PAGE_MULTIPLE); // Simple heuristic: double until 1GB... + } else { + // ..., but after that, add smaller increments towards 2GB, which we cannot reach + newSize = Math.min(alignUp((3 * newSize + 2147483648) / 4, PAGE_MULTIPLE), LIMIT); + } + + } + + + + + if (!emscripten_realloc_buffer(newSize)) { + return false; + } + + updateGlobalBufferViews(); + + + + return true; + } +var ASSERTIONS = false; + +// Copyright 2017 The Emscripten Authors. All rights reserved. +// Emscripten is available under two separate licenses, the MIT license and the +// University of Illinois/NCSA Open Source License. Both these licenses can be +// found in the LICENSE file. + +/** @type {function(string, boolean=, number=)} */ +function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy)+1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; +} + +function intArrayToString(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + var chr = array[i]; + if (chr > 0xFF) { + if (ASSERTIONS) { + assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.'); + } + chr &= 0xFF; + } + ret.push(String.fromCharCode(chr)); + } + return ret.join(''); +} + + +// ASM_LIBRARY EXTERN PRIMITIVES: Int8Array,Int32Array + + +function invoke_ii(index,a1) { + var sp = stackSave(); + try { + return dynCall_ii(index,a1); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iii(index,a1,a2) { + var sp = stackSave(); + try { + return dynCall_iii(index,a1,a2); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iiii(index,a1,a2,a3) { + var sp = stackSave(); + try { + return dynCall_iiii(index,a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiii(index,a1,a2,a3,a4) { + var sp = stackSave(); + try { + return dynCall_iiiii(index,a1,a2,a3,a4); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiii(index,a1,a2,a3,a4,a5) { + var sp = stackSave(); + try { + return dynCall_iiiiii(index,a1,a2,a3,a4,a5); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiii(index,a1,a2,a3,a4,a5,a6) { + var sp = stackSave(); + try { + return dynCall_iiiiiii(index,a1,a2,a3,a4,a5,a6); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_ji(index,a1) { + var sp = stackSave(); + try { + return dynCall_ji(index,a1); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_v(index) { + var sp = stackSave(); + try { + dynCall_v(index); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_vi(index,a1) { + var sp = stackSave(); + try { + dynCall_vi(index,a1); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_vii(index,a1,a2) { + var sp = stackSave(); + try { + dynCall_vii(index,a1,a2); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_viii(index,a1,a2,a3) { + var sp = stackSave(); + try { + dynCall_viii(index,a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_viji(index,a1,a2,a3,a4) { + var sp = stackSave(); + try { + dynCall_viji(index,a1,a2,a3,a4); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +var asmGlobalArg = {}; + +var asmLibraryArg = { + "abort": abort, + "setTempRet0": setTempRet0, + "getTempRet0": getTempRet0, + "invoke_ii": invoke_ii, + "invoke_iii": invoke_iii, + "invoke_iiii": invoke_iiii, + "invoke_iiiii": invoke_iiiii, + "invoke_iiiiii": invoke_iiiiii, + "invoke_iiiiiii": invoke_iiiiiii, + "invoke_ji": invoke_ji, + "invoke_v": invoke_v, + "invoke_vi": invoke_vi, + "invoke_vii": invoke_vii, + "invoke_viii": invoke_viii, + "invoke_viji": invoke_viji, + "___assert_fail": ___assert_fail, + "___cxa_allocate_exception": ___cxa_allocate_exception, + "___cxa_begin_catch": ___cxa_begin_catch, + "___cxa_end_catch": ___cxa_end_catch, + "___cxa_find_matching_catch": ___cxa_find_matching_catch, + "___cxa_find_matching_catch_2": ___cxa_find_matching_catch_2, + "___cxa_find_matching_catch_3": ___cxa_find_matching_catch_3, + "___cxa_free_exception": ___cxa_free_exception, + "___cxa_pure_virtual": ___cxa_pure_virtual, + "___cxa_throw": ___cxa_throw, + "___cxa_uncaught_exceptions": ___cxa_uncaught_exceptions, + "___exception_addRef": ___exception_addRef, + "___exception_deAdjust": ___exception_deAdjust, + "___exception_decRef": ___exception_decRef, + "___gxx_personality_v0": ___gxx_personality_v0, + "___resumeException": ___resumeException, + "___setErrNo": ___setErrNo, + "___syscall140": ___syscall140, + "___syscall146": ___syscall146, + "___syscall54": ___syscall54, + "___syscall6": ___syscall6, + "_abort": _abort, + "_do_error": _do_error, + "_do_progress": _do_progress, + "_emscripten_get_heap_size": _emscripten_get_heap_size, + "_emscripten_memcpy_big": _emscripten_memcpy_big, + "_emscripten_resize_heap": _emscripten_resize_heap, + "_get_file_contents": _get_file_contents, + "_llvm_exp2_f32": _llvm_exp2_f32, + "_llvm_exp2_f64": _llvm_exp2_f64, + "_llvm_trap": _llvm_trap, + "_put_file_contents": _put_file_contents, + "_put_file_size": _put_file_size, + "abortOnCannotGrowMemory": abortOnCannotGrowMemory, + "emscripten_realloc_buffer": emscripten_realloc_buffer, + "flush_NO_FILESYSTEM": flush_NO_FILESYSTEM, + "tempDoublePtr": tempDoublePtr, + "DYNAMICTOP_PTR": DYNAMICTOP_PTR +}; +// EMSCRIPTEN_START_ASM +var asm =Module["asm"]// EMSCRIPTEN_END_ASM +(asmGlobalArg, asmLibraryArg, buffer); + +Module["asm"] = asm; +var _DApi_MpqCmp = Module["_DApi_MpqCmp"] = function() { + return Module["asm"]["_DApi_MpqCmp"].apply(null, arguments) +}; + +var __ZSt18uncaught_exceptionv = Module["__ZSt18uncaught_exceptionv"] = function() { + return Module["asm"]["__ZSt18uncaught_exceptionv"].apply(null, arguments) +}; + +var ___cxa_can_catch = Module["___cxa_can_catch"] = function() { + return Module["asm"]["___cxa_can_catch"].apply(null, arguments) +}; + +var ___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] = function() { + return Module["asm"]["___cxa_is_pointer_type"].apply(null, arguments) +}; + +var ___em_js__do_error = Module["___em_js__do_error"] = function() { + return Module["asm"]["___em_js__do_error"].apply(null, arguments) +}; + +var ___em_js__do_progress = Module["___em_js__do_progress"] = function() { + return Module["asm"]["___em_js__do_progress"].apply(null, arguments) +}; + +var ___em_js__get_file_contents = Module["___em_js__get_file_contents"] = function() { + return Module["asm"]["___em_js__get_file_contents"].apply(null, arguments) +}; + +var ___em_js__put_file_contents = Module["___em_js__put_file_contents"] = function() { + return Module["asm"]["___em_js__put_file_contents"].apply(null, arguments) +}; + +var ___em_js__put_file_size = Module["___em_js__put_file_size"] = function() { + return Module["asm"]["___em_js__put_file_size"].apply(null, arguments) +}; + +var _emscripten_replace_memory = Module["_emscripten_replace_memory"] = function() { + return Module["asm"]["_emscripten_replace_memory"].apply(null, arguments) +}; + +var _free = Module["_free"] = function() { + return Module["asm"]["_free"].apply(null, arguments) +}; + +var _llvm_bswap_i32 = Module["_llvm_bswap_i32"] = function() { + return Module["asm"]["_llvm_bswap_i32"].apply(null, arguments) +}; + +var _malloc = Module["_malloc"] = function() { + return Module["asm"]["_malloc"].apply(null, arguments) +}; + +var _memcpy = Module["_memcpy"] = function() { + return Module["asm"]["_memcpy"].apply(null, arguments) +}; + +var _memmove = Module["_memmove"] = function() { + return Module["asm"]["_memmove"].apply(null, arguments) +}; + +var _memset = Module["_memset"] = function() { + return Module["asm"]["_memset"].apply(null, arguments) +}; + +var _sbrk = Module["_sbrk"] = function() { + return Module["asm"]["_sbrk"].apply(null, arguments) +}; + +var _setThrew = Module["_setThrew"] = function() { + return Module["asm"]["_setThrew"].apply(null, arguments) +}; + +var establishStackSpace = Module["establishStackSpace"] = function() { + return Module["asm"]["establishStackSpace"].apply(null, arguments) +}; + +var stackAlloc = Module["stackAlloc"] = function() { + return Module["asm"]["stackAlloc"].apply(null, arguments) +}; + +var stackRestore = Module["stackRestore"] = function() { + return Module["asm"]["stackRestore"].apply(null, arguments) +}; + +var stackSave = Module["stackSave"] = function() { + return Module["asm"]["stackSave"].apply(null, arguments) +}; + +var dynCall_ii = Module["dynCall_ii"] = function() { + return Module["asm"]["dynCall_ii"].apply(null, arguments) +}; + +var dynCall_iidiiii = Module["dynCall_iidiiii"] = function() { + return Module["asm"]["dynCall_iidiiii"].apply(null, arguments) +}; + +var dynCall_iii = Module["dynCall_iii"] = function() { + return Module["asm"]["dynCall_iii"].apply(null, arguments) +}; + +var dynCall_iiii = Module["dynCall_iiii"] = function() { + return Module["asm"]["dynCall_iiii"].apply(null, arguments) +}; + +var dynCall_iiiii = Module["dynCall_iiiii"] = function() { + return Module["asm"]["dynCall_iiiii"].apply(null, arguments) +}; + +var dynCall_iiiiii = Module["dynCall_iiiiii"] = function() { + return Module["asm"]["dynCall_iiiiii"].apply(null, arguments) +}; + +var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = function() { + return Module["asm"]["dynCall_iiiiiii"].apply(null, arguments) +}; + +var dynCall_ji = Module["dynCall_ji"] = function() { + return Module["asm"]["dynCall_ji"].apply(null, arguments) +}; + +var dynCall_jiji = Module["dynCall_jiji"] = function() { + return Module["asm"]["dynCall_jiji"].apply(null, arguments) +}; + +var dynCall_v = Module["dynCall_v"] = function() { + return Module["asm"]["dynCall_v"].apply(null, arguments) +}; + +var dynCall_vi = Module["dynCall_vi"] = function() { + return Module["asm"]["dynCall_vi"].apply(null, arguments) +}; + +var dynCall_vii = Module["dynCall_vii"] = function() { + return Module["asm"]["dynCall_vii"].apply(null, arguments) +}; + +var dynCall_viii = Module["dynCall_viii"] = function() { + return Module["asm"]["dynCall_viii"].apply(null, arguments) +}; + +var dynCall_viiii = Module["dynCall_viiii"] = function() { + return Module["asm"]["dynCall_viiii"].apply(null, arguments) +}; + +var dynCall_viiiii = Module["dynCall_viiiii"] = function() { + return Module["asm"]["dynCall_viiiii"].apply(null, arguments) +}; + +var dynCall_viiiiii = Module["dynCall_viiiiii"] = function() { + return Module["asm"]["dynCall_viiiiii"].apply(null, arguments) +}; + +var dynCall_viji = Module["dynCall_viji"] = function() { + return Module["asm"]["dynCall_viji"].apply(null, arguments) +}; +; + + + +// === Auto-generated postamble setup entry stuff === + +Module['asm'] = asm; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +// Modularize mode returns a function, which can be called to +// create instances. The instances provide a then() method, +// must like a Promise, that receives a callback. The callback +// is called when the module is ready to run, with the module +// as a parameter. (Like a Promise, it also returns the module +// so you can use the output of .then(..)). +Module['then'] = function(func) { + // We may already be ready to run code at this time. if + // so, just queue a call to the callback. + if (Module['calledRun']) { + func(Module); + } else { + // we are not ready to call then() yet. we must call it + // at the same time we would call onRuntimeInitialized. + var old = Module['onRuntimeInitialized']; + Module['onRuntimeInitialized'] = function() { + if (old) old(); + func(Module); + }; + } + return Module; +}; + +/** + * @constructor + * @extends {Error} + * @this {ExitStatus} + */ +function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; +} +ExitStatus.prototype = new Error(); +ExitStatus.prototype.constructor = ExitStatus; + +var calledMain = false; + +dependenciesFulfilled = function runCaller() { + // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false) + if (!Module['calledRun']) run(); + if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled +}; + + + + + +/** @type {function(Array=)} */ +function run(args) { + args = args || Module['arguments']; + + if (runDependencies > 0) { + return; + } + + + preRun(); + + if (runDependencies > 0) return; // a preRun added a dependency, run will be called later + if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame + + function doRun() { + if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening + Module['calledRun'] = true; + + if (ABORT) return; + + initRuntime(); + + preMain(); + + 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; + + +function exit(status, implicit) { + + // if this is just main exit-ing implicitly, and the status is 0, then we + // don't need to do anything here and can just leave. if the status is + // non-zero, though, then we need to report it. + // (we may have warned about this earlier, if a situation justifies doing so) + if (implicit && Module['noExitRuntime'] && status === 0) { + return; + } + + if (Module['noExitRuntime']) { + } else { + + ABORT = true; + EXITSTATUS = status; + + exitRuntime(); + + if (Module['onExit']) Module['onExit'](status); + } + + Module['quit'](status, new ExitStatus(status)); +} + +var abortDecorators = []; + +function abort(what) { + if (Module['onAbort']) { + Module['onAbort'](what); + } + + what += ''; + out(what); + err(what); + + ABORT = true; + EXITSTATUS = 1; + + throw 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.'; +} +Module['abort'] = abort; + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + + + Module["noExitRuntime"] = true; + +run(); + + + + + +// {{MODULE_ADDITIONS}} + + + +Module['ready'] = new Promise(function (resolve, reject) { + delete Module['then'] + Module['onAbort'] = function (what) { + reject(what) + } + addOnPostRun(function () { + resolve(Module) + }) +}); + + + + return MpqCmp +} +); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = MpqCmp; + else if (typeof define === 'function' && define['amd']) + define([], function() { return MpqCmp; }); + else if (typeof exports === 'object') + exports["MpqCmp"] = MpqCmp; + \ No newline at end of file diff --git a/src/mpqcmp/MpqCmp.wasm b/src/mpqcmp/MpqCmp.wasm new file mode 100644 index 0000000000000000000000000000000000000000..2e07d00303c4689dfa71c4098d4552e637b531b8 GIT binary patch literal 356747 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Ν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 literal 0 HcmV?d00001 diff --git a/src/mpqcmp/mpqcmp.worker.js b/src/mpqcmp/mpqcmp.worker.js new file mode 100644 index 0000000..2ffdbb9 --- /dev/null +++ b/src/mpqcmp/mpqcmp.worker.js @@ -0,0 +1,114 @@ +import MpqBinary from './MpqCmp.wasm'; +import MpqModule from './MpqCmp.jscc'; +import axios from 'axios'; + +const MpqSize = 356747; + +/* eslint-disable-next-line no-restricted-globals */ +const worker = self; + +function onError(err, action="error") { + if (err instanceof Error) { + worker.postMessage({action, error: err.toString(), stack: err.stack}); + } else { + worker.postMessage({action, error: err.toString()}); + } +} + +let input_file = null; +let output_file = null; +let last_progress = 0; +function progress(text, loaded, total) { + worker.postMessage({action: "progress", text, loaded, total}); +} + +const DApi = { + exit_error(error) { + throw Error(error); + }, + + get_file_contents(array, offset) { + array.set(input_file.subarray(offset, offset + array.byteLength)); + }, + put_file_size(size) { + output_file = new Uint8Array(size); + }, + put_file_contents(array, offset) { + output_file.set(array, offset); + }, + + progress(done, total) { + if (done === total || performance.now() > last_progress + 100) { + progress("Processing...", done, total); + last_progress = performance.now(); + } + }, +}; + +worker.DApi = DApi; + +let wasm = null; + +const readFile = (file, progress) => new Promise((resolve, reject) => { + const reader = new FileReader(); + reader.onload = () => { + if (progress) { + progress({loaded: file.size}); + } + resolve(reader.result); + }; + reader.onerror = () => reject(reader.error); + reader.onabort = () => reject(); + if (progress) { + reader.addEventListener("progress", progress); + } + reader.readAsArrayBuffer(file); +}); + +async function initWasm(spawn, progress) { + const binary = await axios.request({ + url: spawn ? SpawnBinary : DiabloBinary, + responseType: 'arraybuffer', + onDownloadProgress: progress, + }); + const result = await (spawn ? SpawnModule : DiabloModule)({wasmBinary: binary.data}).ready; + progress({loaded: 2000000}); + return result; +} + +async function run(mpq) { + progress("Loading..."); + let mpqLoaded = 0, mpqTotal = (mpq ? mpq.size : 0), wasmLoaded = 0, wasmTotal = (spawn ? SpawnSize : DiabloSize); + const wasmWeight = 5; + function updateProgress() { + progress("Loading...", mpqLoaded + wasmLoaded * wasmWeight, mpqTotal + wasmTotal * wasmWeight); + } + const loadWasm = initWasm(spawn, e => { + wasmLoaded = Math.min(e.loaded, wasmTotal); + updateProgress(); + }); + let loadMpq = mpq ? readFile(mpq, e => { + mpqLoaded = e.loaded; + updateProgress(); + }) : Promise.resolve(null); + [wasm, mpq] = await Promise.all([loadWasm, loadMpq]); + + input_file = new Uint8Array(mpq); + + progress("Initializing..."); + + wasm._DApi_MpqCmp(input_file.length); + + return output_file.buffer; +} + +worker.addEventListener("message", ({data}) => { + switch (data.action) { + case "run": + init_game(data.mpq).then( + res => worker.postMessage({action: "result", data: res}, [res]), + e => onError(e, "failed")); + break; + default: + } +});