| // The Module object: Our interface to the outside world. We import |
| // and export values on it, and do the work to get that through |
| // closure compiler if necessary. 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 do an eval in order to handle the closure compiler |
| // case, where this code here is minified but Module was defined |
| // elsewhere (e.g. case 4 above). We also need to check if Module |
| // already exists (e.g. case 3 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; |
| if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {}; |
| |
| // 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 = {}; |
| for (var key in Module) { |
| if (Module.hasOwnProperty(key)) { |
| moduleOverrides[key] = Module[key]; |
| } |
| } |
| |
| // The environment setup code below is customized to use Module. |
| // *** Environment setup code *** |
| var ENVIRONMENT_IS_WEB = false; |
| var ENVIRONMENT_IS_WORKER = false; |
| var ENVIRONMENT_IS_NODE = false; |
| var ENVIRONMENT_IS_SHELL = false; |
| |
| // 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) |
| |
| if (Module['ENVIRONMENT']) { |
| if (Module['ENVIRONMENT'] === 'WEB') { |
| ENVIRONMENT_IS_WEB = true; |
| } else if (Module['ENVIRONMENT'] === 'WORKER') { |
| ENVIRONMENT_IS_WORKER = true; |
| } else if (Module['ENVIRONMENT'] === 'NODE') { |
| ENVIRONMENT_IS_NODE = true; |
| } else if (Module['ENVIRONMENT'] === 'SHELL') { |
| ENVIRONMENT_IS_SHELL = true; |
| } else { |
| throw new Error('The provided Module[\'ENVIRONMENT\'] value is not valid. It must be one of: WEB|WORKER|NODE|SHELL.'); |
| } |
| } else { |
| ENVIRONMENT_IS_WEB = typeof window === 'object'; |
| ENVIRONMENT_IS_WORKER = typeof importScripts === 'function'; |
| ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function' && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER; |
| ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; |
| } |
| |
| |
| if (ENVIRONMENT_IS_NODE) { |
| // Expose functionality in the same simple way that the shells work |
| // Note that we pollute the global namespace here, otherwise we break in node |
| if (!Module['print']) Module['print'] = console.log; |
| if (!Module['printErr']) Module['printErr'] = console.warn; |
| |
| var nodeFS; |
| var nodePath; |
| |
| Module['read'] = function read(filename, binary) { |
| if (!nodeFS) nodeFS = require('fs'); |
| if (!nodePath) nodePath = require('path'); |
| filename = nodePath['normalize'](filename); |
| var ret = nodeFS['readFileSync'](filename); |
| return binary ? ret : ret.toString(); |
| }; |
| |
| Module['readBinary'] = function readBinary(filename) { |
| var ret = Module['read'](filename, true); |
| if (!ret.buffer) { |
| ret = new Uint8Array(ret); |
| } |
| assert(ret.buffer); |
| return ret; |
| }; |
| |
| Module['load'] = function load(f) { |
| globalEval(read(f)); |
| }; |
| |
| if (!Module['thisProgram']) { |
| if (process['argv'].length > 1) { |
| Module['thisProgram'] = process['argv'][1].replace(/\\/g, '/'); |
| } else { |
| Module['thisProgram'] = 'unknown-program'; |
| } |
| } |
| |
| Module['arguments'] = process['argv'].slice(2); |
| |
| if (typeof module !== 'undefined') { |
| module['exports'] = Module; |
| } |
| |
| process['on']('uncaughtException', function(ex) { |
| // suppress ExitStatus exceptions from showing an error |
| if (!(ex instanceof ExitStatus)) { |
| throw ex; |
| } |
| }); |
| |
| Module['inspect'] = function () { return '[Emscripten Module object]'; }; |
| } |
| else if (ENVIRONMENT_IS_SHELL) { |
| if (!Module['print']) Module['print'] = print; |
| if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm |
| |
| if (typeof read != 'undefined') { |
| Module['read'] = read; |
| } else { |
| Module['read'] = function read() { throw 'no read() available' }; |
| } |
| |
| Module['readBinary'] = function readBinary(f) { |
| if (typeof readbuffer === 'function') { |
| return new Uint8Array(readbuffer(f)); |
| } |
| var 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, toThrow) { |
| quit(status); |
| } |
| } |
| |
| } |
| else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { |
| Module['read'] = function read(url) { |
| var xhr = new XMLHttpRequest(); |
| xhr.open('GET', url, false); |
| xhr.send(null); |
| return xhr.responseText; |
| }; |
| |
| if (ENVIRONMENT_IS_WORKER) { |
| Module['readBinary'] = function read(url) { |
| var xhr = new XMLHttpRequest(); |
| xhr.open('GET', url, false); |
| xhr.responseType = 'arraybuffer'; |
| xhr.send(null); |
| return xhr.response; |
| }; |
| } |
| |
| Module['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); |
| } else { |
| onerror(); |
| } |
| }; |
| xhr.onerror = onerror; |
| xhr.send(null); |
| }; |
| |
| if (typeof arguments != 'undefined') { |
| Module['arguments'] = arguments; |
| } |
| |
| if (typeof console !== 'undefined') { |
| if (!Module['print']) Module['print'] = function print(x) { |
| console.log(x); |
| }; |
| if (!Module['printErr']) Module['printErr'] = function printErr(x) { |
| console.warn(x); |
| }; |
| } else { |
| // Probably a worker, and without console.log. We can do very little here... |
| var TRY_USE_DUMP = false; |
| if (!Module['print']) Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) { |
| dump(x); |
| }) : (function(x) { |
| // self.postMessage(x); // enable this if you want stdout to be sent as messages |
| })); |
| } |
| |
| if (ENVIRONMENT_IS_WORKER) { |
| Module['load'] = importScripts; |
| } |
| |
| if (typeof Module['setWindowTitle'] === 'undefined') { |
| Module['setWindowTitle'] = function(title) { document.title = title }; |
| } |
| } |
| else { |
| // Unreachable because SHELL is dependant on the others |
| throw 'Unknown runtime environment. Where are we?'; |
| } |
| |
| function globalEval(x) { |
| eval.call(null, x); |
| } |
| if (!Module['load'] && Module['read']) { |
| Module['load'] = function load(f) { |
| globalEval(Module['read'](f)); |
| }; |
| } |
| if (!Module['print']) { |
| Module['print'] = function(){}; |
| } |
| if (!Module['printErr']) { |
| Module['printErr'] = Module['print']; |
| } |
| if (!Module['arguments']) { |
| Module['arguments'] = []; |
| } |
| if (!Module['thisProgram']) { |
| Module['thisProgram'] = './this.program'; |
| } |
| if (!Module['quit']) { |
| Module['quit'] = function(status, toThrow) { |
| throw toThrow; |
| } |
| } |
| |
| // *** Environment setup code *** |
| |
| // Closure helpers |
| Module.print = Module['print']; |
| Module.printErr = Module['printErr']; |
| |
| // Callbacks |
| Module['preRun'] = []; |
| Module['postRun'] = []; |
| |
| // Merge back in the overrides |
| for (var 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; |
| |
| |
| |
| // {{PREAMBLE_ADDITIONS}} |
| |
| // === 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 |
| |
| //======================================== |
| // Runtime code shared with compiler |
| //======================================== |
| |
| var Runtime = { |
| setTempRet0: function (value) { |
| tempRet0 = value; |
| return value; |
| }, |
| getTempRet0: function () { |
| return tempRet0; |
| }, |
| stackSave: function () { |
| return STACKTOP; |
| }, |
| stackRestore: function (stackTop) { |
| STACKTOP = stackTop; |
| }, |
| getNativeTypeSize: function (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 Runtime.QUANTUM_SIZE; // A pointer |
| } else if (type[0] === 'i') { |
| var bits = parseInt(type.substr(1)); |
| assert(bits % 8 === 0); |
| return bits/8; |
| } else { |
| return 0; |
| } |
| } |
| } |
| }, |
| getNativeFieldSize: function (type) { |
| return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE); |
| }, |
| STACK_ALIGN: 16, |
| prepVararg: function (ptr, type) { |
| if (type === 'double' || type === 'i64') { |
| // move so the load is aligned |
| if (ptr & 7) { |
| assert((ptr & 7) === 4); |
| ptr += 4; |
| } |
| } else { |
| assert((ptr & 3) === 0); |
| } |
| return ptr; |
| }, |
| getAlignSize: function (type, size, vararg) { |
| // we align i64s and doubles on 64-bit boundaries, unlike x86 |
| if (!vararg && (type == 'i64' || type == 'double')) return 8; |
| if (!type) return Math.min(size, 8); // align structures internally to 64 bits |
| return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE); |
| }, |
| dynCall: function (sig, ptr, args) { |
| if (args && args.length) { |
| assert(args.length == sig.length-1); |
| assert(('dynCall_' + sig) in Module, 'bad function pointer type - no table for sig \'' + sig + '\''); |
| return Module['dynCall_' + sig].apply(null, [ptr].concat(args)); |
| } else { |
| assert(sig.length == 1); |
| assert(('dynCall_' + sig) in Module, 'bad function pointer type - no table for sig \'' + sig + '\''); |
| return Module['dynCall_' + sig].call(null, ptr); |
| } |
| }, |
| functionPointers: [], |
| addFunction: function (func) { |
| for (var i = 0; i < Runtime.functionPointers.length; i++) { |
| if (!Runtime.functionPointers[i]) { |
| Runtime.functionPointers[i] = func; |
| return 2*(1 + i); |
| } |
| } |
| throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.'; |
| }, |
| removeFunction: function (index) { |
| Runtime.functionPointers[(index-2)/2] = null; |
| }, |
| warnOnce: function (text) { |
| if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {}; |
| if (!Runtime.warnOnce.shown[text]) { |
| Runtime.warnOnce.shown[text] = 1; |
| Module.printErr(text); |
| } |
| }, |
| funcWrappers: {}, |
| getFuncWrapper: function (func, sig) { |
| assert(sig); |
| if (!Runtime.funcWrappers[sig]) { |
| Runtime.funcWrappers[sig] = {}; |
| } |
| var sigCache = Runtime.funcWrappers[sig]; |
| if (!sigCache[func]) { |
| // optimize away arguments usage in common cases |
| if (sig.length === 1) { |
| sigCache[func] = function dynCall_wrapper() { |
| return Runtime.dynCall(sig, func); |
| }; |
| } else if (sig.length === 2) { |
| sigCache[func] = function dynCall_wrapper(arg) { |
| return Runtime.dynCall(sig, func, [arg]); |
| }; |
| } else { |
| // general case |
| sigCache[func] = function dynCall_wrapper() { |
| return Runtime.dynCall(sig, func, Array.prototype.slice.call(arguments)); |
| }; |
| } |
| } |
| return sigCache[func]; |
| }, |
| getCompilerSetting: function (name) { |
| throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work'; |
| }, |
| stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+15)&-16);(assert((((STACKTOP|0) < (STACK_MAX|0))|0))|0); return ret; }, |
| staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + (assert(!staticSealed),size))|0;STATICTOP = (((STATICTOP)+15)&-16); return ret; }, |
| dynamicAlloc: function (size) { assert(DYNAMICTOP_PTR);var ret = HEAP32[DYNAMICTOP_PTR>>2];var end = (((ret + size + 15)|0) & -16);HEAP32[DYNAMICTOP_PTR>>2] = end;if (end >= TOTAL_MEMORY) {var success = enlargeMemory();if (!success) {HEAP32[DYNAMICTOP_PTR>>2] = ret;return 0;}}return ret;}, |
| alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 16))*(quantum ? quantum : 16); return ret; }, |
| makeBigInt: function (low,high,unsigned) { var ret = (unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0))); return ret; }, |
| GLOBAL_BASE: 1024, |
| QUANTUM_SIZE: 4, |
| __dummy__: 0 |
| } |
| |
| |
| |
| Module["Runtime"] = Runtime; |
| |
| |
| |
| //======================================== |
| // Runtime essentials |
| //======================================== |
| |
| var ABORT = 0; // whether we are quitting the application. no code should run after this. set in exit() and abort() |
| var EXITSTATUS = 0; |
| |
| function assert(condition, text) { |
| if (!condition) { |
| abort('Assertion failed: ' + text); |
| } |
| } |
| |
| var globalScope = this; |
| |
| // 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 |
| if (!func) { |
| try { func = eval('_' + ident); } catch(e) {} |
| } |
| assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)'); |
| return func; |
| } |
| |
| var cwrap, ccall; |
| (function(){ |
| var JSfuncs = { |
| // Helpers for cwrap -- it can't refer to Runtime directly because it might |
| // be renamed by closure, instead it calls JSfuncs['stackSave'].body to find |
| // out what the minified function name is. |
| 'stackSave': function() { |
| Runtime.stackSave() |
| }, |
| 'stackRestore': function() { |
| Runtime.stackRestore() |
| }, |
| // type conversion from js to c |
| 'arrayToC' : function(arr) { |
| var ret = Runtime.stackAlloc(arr.length); |
| writeArrayToMemory(arr, ret); |
| return ret; |
| }, |
| 'stringToC' : 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 = Runtime.stackAlloc(len); |
| stringToUTF8(str, ret, len); |
| } |
| return ret; |
| } |
| }; |
| // For fast lookup of conversion functions |
| var toC = {'string' : JSfuncs['stringToC'], 'array' : JSfuncs['arrayToC']}; |
| |
| // C calling interface. |
| ccall = function ccallFunc(ident, returnType, argTypes, args, opts) { |
| var func = getCFunc(ident); |
| var cArgs = []; |
| var stack = 0; |
| assert(returnType !== 'array', 'Return type should not be "array".'); |
| if (args) { |
| for (var i = 0; i < args.length; i++) { |
| var converter = toC[argTypes[i]]; |
| if (converter) { |
| if (stack === 0) stack = Runtime.stackSave(); |
| cArgs[i] = converter(args[i]); |
| } else { |
| cArgs[i] = args[i]; |
| } |
| } |
| } |
| var ret = func.apply(null, cArgs); |
| if ((!opts || !opts.async) && typeof EmterpreterAsync === 'object') { |
| assert(!EmterpreterAsync.state, 'cannot start async op with normal JS calling ccall'); |
| } |
| if (opts && opts.async) assert(!returnType, 'async ccalls cannot return values'); |
| if (returnType === 'string') ret = Pointer_stringify(ret); |
| if (stack !== 0) { |
| if (opts && opts.async) { |
| EmterpreterAsync.asyncFinalizers.push(function() { |
| Runtime.stackRestore(stack); |
| }); |
| return; |
| } |
| Runtime.stackRestore(stack); |
| } |
| return ret; |
| } |
| |
| var sourceRegex = /^function\s*[a-zA-Z$_0-9]*\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/; |
| function parseJSFunc(jsfunc) { |
| // Match the body and the return value of a javascript function source |
| var parsed = jsfunc.toString().match(sourceRegex).slice(1); |
| return {arguments : parsed[0], body : parsed[1], returnValue: parsed[2]} |
| } |
| |
| // sources of useful functions. we create this lazily as it can trigger a source decompression on this entire file |
| var JSsource = null; |
| function ensureJSsource() { |
| if (!JSsource) { |
| JSsource = {}; |
| for (var fun in JSfuncs) { |
| if (JSfuncs.hasOwnProperty(fun)) { |
| // Elements of toCsource are arrays of three items: |
| // the code, and the return value |
| JSsource[fun] = parseJSFunc(JSfuncs[fun]); |
| } |
| } |
| } |
| } |
| |
| cwrap = function cwrap(ident, returnType, argTypes) { |
| argTypes = argTypes || []; |
| var cfunc = getCFunc(ident); |
| // 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) { |
| return cfunc; |
| } |
| // Creation of the arguments list (["$1","$2",...,"$nargs"]) |
| var argNames = argTypes.map(function(x,i){return '$'+i}); |
| var funcstr = "(function(" + argNames.join(',') + ") {"; |
| var nargs = argTypes.length; |
| if (!numericArgs) { |
| // Generate the code needed to convert the arguments from javascript |
| // values to pointers |
| ensureJSsource(); |
| funcstr += 'var stack = ' + JSsource['stackSave'].body + ';'; |
| for (var i = 0; i < nargs; i++) { |
| var arg = argNames[i], type = argTypes[i]; |
| if (type === 'number') continue; |
| var convertCode = JSsource[type + 'ToC']; // [code, return] |
| funcstr += 'var ' + convertCode.arguments + ' = ' + arg + ';'; |
| funcstr += convertCode.body + ';'; |
| funcstr += arg + '=(' + convertCode.returnValue + ');'; |
| } |
| } |
| |
| // When the code is compressed, the name of cfunc is not literally 'cfunc' anymore |
| var cfuncname = parseJSFunc(function(){return cfunc}).returnValue; |
| // Call the function |
| funcstr += 'var ret = ' + cfuncname + '(' + argNames.join(',') + ');'; |
| if (!numericRet) { // Return type can only by 'string' or 'number' |
| // Convert the result to a string |
| var strgfy = parseJSFunc(function(){return Pointer_stringify}).returnValue; |
| funcstr += 'ret = ' + strgfy + '(ret);'; |
| } |
| funcstr += "if (typeof EmterpreterAsync === 'object') { assert(!EmterpreterAsync.state, 'cannot start async op with normal JS calling cwrap') }"; |
| if (!numericArgs) { |
| // If we had a stack, restore it |
| ensureJSsource(); |
| funcstr += JSsource['stackRestore'].body.replace('()', '(stack)') + ';'; |
| } |
| funcstr += 'return ret})'; |
| return eval(funcstr); |
| }; |
| })(); |
| Module["ccall"] = ccall; |
| Module["cwrap"] = cwrap; |
| |
| 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); |
| } |
| } |
| Module["setValue"] = setValue; |
| |
| |
| 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 setValue: ' + type); |
| } |
| return null; |
| } |
| Module["getValue"] = getValue; |
| |
| var ALLOC_NORMAL = 0; // Tries to use _malloc() |
| var ALLOC_STACK = 1; // Lives for the duration of the current function call |
| var ALLOC_STATIC = 2; // Cannot be freed |
| var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk |
| var ALLOC_NONE = 4; // Do not allocate |
| Module["ALLOC_NORMAL"] = ALLOC_NORMAL; |
| Module["ALLOC_STACK"] = ALLOC_STACK; |
| Module["ALLOC_STATIC"] = ALLOC_STATIC; |
| Module["ALLOC_DYNAMIC"] = ALLOC_DYNAMIC; |
| Module["ALLOC_NONE"] = ALLOC_NONE; |
| |
| // 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_* |
| 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 = [typeof _malloc === 'function' ? _malloc : Runtime.staticAlloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length)); |
| } |
| |
| if (zeroinit) { |
| var ptr = ret, stop; |
| 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(slab, ret); |
| } else { |
| HEAPU8.set(new Uint8Array(slab), ret); |
| } |
| return ret; |
| } |
| |
| var i = 0, type, typeSize, previousType; |
| while (i < size) { |
| var curr = slab[i]; |
| |
| if (typeof curr === 'function') { |
| curr = Runtime.getFunctionIndex(curr); |
| } |
| |
| type = singleType || types[i]; |
| if (type === 0) { |
| i++; |
| continue; |
| } |
| assert(type, 'Must know what type to store in allocate!'); |
| |
| 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 = Runtime.getNativeTypeSize(type); |
| previousType = type; |
| } |
| i += typeSize; |
| } |
| |
| return ret; |
| } |
| Module["allocate"] = allocate; |
| |
| // Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready |
| function getMemory(size) { |
| if (!staticSealed) return Runtime.staticAlloc(size); |
| if (!runtimeInitialized) return Runtime.dynamicAlloc(size); |
| return _malloc(size); |
| } |
| Module["getMemory"] = getMemory; |
| |
| function Pointer_stringify(ptr, /* optional */ length) { |
| if (length === 0 || !ptr) return ''; |
| // TODO: use TextDecoder |
| // Find the length, and check for UTF while doing so |
| var hasUtf = 0; |
| var t; |
| var i = 0; |
| while (1) { |
| assert(ptr + i < TOTAL_MEMORY); |
| t = HEAPU8[(((ptr)+(i))>>0)]; |
| hasUtf |= t; |
| if (t == 0 && !length) break; |
| i++; |
| if (length && i == length) break; |
| } |
| if (!length) length = i; |
| |
| var ret = ''; |
| |
| if (hasUtf < 128) { |
| var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack |
| var curr; |
| while (length > 0) { |
| curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK))); |
| ret = ret ? ret + curr : curr; |
| ptr += MAX_CHUNK; |
| length -= MAX_CHUNK; |
| } |
| return ret; |
| } |
| return Module['UTF8ToString'](ptr); |
| } |
| Module["Pointer_stringify"] = Pointer_stringify; |
| |
| // 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 = HEAP8[((ptr++)>>0)]; |
| if (!ch) return str; |
| str += String.fromCharCode(ch); |
| } |
| } |
| Module["AsciiToString"] = AsciiToString; |
| |
| // 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); |
| } |
| Module["stringToAscii"] = stringToAscii; |
| |
| // 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; |
| function UTF8ArrayToString(u8Array, idx) { |
| 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. |
| while (u8Array[endPtr]) ++endPtr; |
| |
| if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) { |
| return UTF8Decoder.decode(u8Array.subarray(idx, endPtr)); |
| } else { |
| var u0, u1, u2, u3, u4, u5; |
| |
| var str = ''; |
| while (1) { |
| // 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 |
| u0 = u8Array[idx++]; |
| if (!u0) return str; |
| if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } |
| u1 = u8Array[idx++] & 63; |
| if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } |
| u2 = u8Array[idx++] & 63; |
| if ((u0 & 0xF0) == 0xE0) { |
| u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; |
| } else { |
| u3 = u8Array[idx++] & 63; |
| if ((u0 & 0xF8) == 0xF0) { |
| u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | u3; |
| } else { |
| u4 = u8Array[idx++] & 63; |
| if ((u0 & 0xFC) == 0xF8) { |
| u0 = ((u0 & 3) << 24) | (u1 << 18) | (u2 << 12) | (u3 << 6) | u4; |
| } else { |
| u5 = u8Array[idx++] & 63; |
| u0 = ((u0 & 1) << 30) | (u1 << 24) | (u2 << 18) | (u3 << 12) | (u4 << 6) | u5; |
| } |
| } |
| } |
| if (u0 < 0x10000) { |
| str += String.fromCharCode(u0); |
| } else { |
| var ch = u0 - 0x10000; |
| str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); |
| } |
| } |
| } |
| } |
| Module["UTF8ArrayToString"] = UTF8ArrayToString; |
| |
| // 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. |
| |
| function UTF8ToString(ptr) { |
| return UTF8ArrayToString(HEAPU8,ptr); |
| } |
| Module["UTF8ToString"] = UTF8ToString; |
| |
| // 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) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 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 (u <= 0x1FFFFF) { |
| 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); |
| } else if (u <= 0x3FFFFFF) { |
| if (outIdx + 4 >= endIdx) break; |
| outU8Array[outIdx++] = 0xF8 | (u >> 24); |
| outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63); |
| outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); |
| outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); |
| outU8Array[outIdx++] = 0x80 | (u & 63); |
| } else { |
| if (outIdx + 5 >= endIdx) break; |
| outU8Array[outIdx++] = 0xFC | (u >> 30); |
| outU8Array[outIdx++] = 0x80 | ((u >> 24) & 63); |
| outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63); |
| 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; |
| } |
| Module["stringToUTF8Array"] = stringToUTF8Array; |
| |
| // 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) { |
| assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); |
| return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite); |
| } |
| Module["stringToUTF8"] = stringToUTF8; |
| |
| // 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 if (u <= 0x1FFFFF) { |
| len += 4; |
| } else if (u <= 0x3FFFFFF) { |
| len += 5; |
| } else { |
| len += 6; |
| } |
| } |
| return len; |
| } |
| Module["lengthBytesUTF8"] = lengthBytesUTF8; |
| |
| // 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) { |
| assert(ptr % 2 == 0, 'Pointer passed to UTF16ToString must be aligned to two bytes!'); |
| 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) { |
| assert(outPtr % 2 == 0, 'Pointer passed to stringToUTF16 must be aligned to two bytes!'); |
| assert(typeof maxBytesToWrite == 'number', 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); |
| // 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) { |
| assert(ptr % 4 == 0, 'Pointer passed to UTF32ToString must be aligned to four bytes!'); |
| 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) { |
| assert(outPtr % 4 == 0, 'Pointer passed to stringToUTF32 must be aligned to four bytes!'); |
| assert(typeof maxBytesToWrite == 'number', 'stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); |
| // 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; |
| } |
| |
| |
| function demangle(func) { |
| var __cxa_demangle_func = Module['___cxa_demangle'] || Module['__cxa_demangle']; |
| if (__cxa_demangle_func) { |
| try { |
| var s = |
| func.substr(1); |
| var len = lengthBytesUTF8(s)+1; |
| var buf = _malloc(len); |
| stringToUTF8(s, buf, len); |
| var status = _malloc(4); |
| var ret = __cxa_demangle_func(buf, 0, 0, status); |
| if (getValue(status, 'i32') === 0 && ret) { |
| return Pointer_stringify(ret); |
| } |
| // otherwise, libcxxabi failed |
| } catch(e) { |
| // ignore problems here |
| } finally { |
| if (buf) _free(buf); |
| if (status) _free(status); |
| if (ret) _free(ret); |
| } |
| // failure when using libcxxabi, don't demangle |
| return func; |
| } |
| Runtime.warnOnce('warning: build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling'); |
| 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 : (x + ' [' + y + ']'); |
| }); |
| } |
| |
| 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); |
| } |
| Module["stackTrace"] = stackTrace; |
| |
| // Memory management |
| |
| var PAGE_SIZE = 16384; |
| var WASM_PAGE_SIZE = 65536; |
| var ASMJS_PAGE_SIZE = 16777216; |
| var MIN_TOTAL_MEMORY = 16777216; |
| |
| function alignUp(x, multiple) { |
| if (x % multiple > 0) { |
| x += multiple - (x % multiple); |
| } |
| return x; |
| } |
| |
| var HEAP; |
| var buffer; |
| var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64; |
| |
| function updateGlobalBuffer(buf) { |
| Module['buffer'] = buffer = buf; |
| } |
| |
| 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, STATICTOP, staticSealed; // static area |
| var STACK_BASE, STACKTOP, STACK_MAX; // stack area |
| var DYNAMIC_BASE, DYNAMICTOP_PTR; // dynamic area handled by sbrk |
| |
| STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0; |
| staticSealed = false; |
| |
| |
| // Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode. |
| function writeStackCookie() { |
| assert((STACK_MAX & 3) == 0); |
| HEAPU32[(STACK_MAX >> 2)-1] = 0x02135467; |
| HEAPU32[(STACK_MAX >> 2)-2] = 0x89BACDFE; |
| } |
| |
| function checkStackCookie() { |
| if (HEAPU32[(STACK_MAX >> 2)-1] != 0x02135467 || HEAPU32[(STACK_MAX >> 2)-2] != 0x89BACDFE) { |
| abort('Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x02135467, but received 0x' + HEAPU32[(STACK_MAX >> 2)-2].toString(16) + ' ' + HEAPU32[(STACK_MAX >> 2)-1].toString(16)); |
| } |
| // Also test the global address 0 for integrity. This check is not compatible with SAFE_SPLIT_MEMORY though, since that mode already tests all address 0 accesses on its own. |
| if (HEAP32[0] !== 0x63736d65 /* 'emsc' */) throw 'Runtime error: The application has corrupted its heap memory area (address zero)!'; |
| } |
| |
| function abortStackOverflow(allocSize) { |
| abort('Stack overflow! Attempted to allocate ' + allocSize + ' bytes on the stack, but stack has only ' + (STACK_MAX - Module['asm'].stackSave() + allocSize) + ' bytes available!'); |
| } |
| |
| function abortOnCannotGrowMemory() { |
| abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 '); |
| } |
| |
| |
| function enlargeMemory() { |
| abortOnCannotGrowMemory(); |
| } |
| |
| |
| var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880; |
| var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 16777216; |
| if (TOTAL_MEMORY < TOTAL_STACK) Module.printErr('TOTAL_MEMORY should be larger than TOTAL_STACK, was ' + TOTAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')'); |
| |
| // Initialize the runtime's memory |
| // check for full engine support (use string 'subarray' to avoid closure compiler confusion) |
| assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']), |
| 'JS engine does not provide full typed array support'); |
| |
| |
| |
| // Use a provided buffer, if there is one, or else allocate a new one |
| if (Module['buffer']) { |
| buffer = Module['buffer']; |
| assert(buffer.byteLength === TOTAL_MEMORY, 'provided buffer should be ' + TOTAL_MEMORY + ' bytes, but it is ' + buffer.byteLength); |
| } else { |
| // Use a WebAssembly memory where available |
| if (typeof WebAssembly === 'object' && typeof WebAssembly.Memory === 'function') { |
| assert(TOTAL_MEMORY % WASM_PAGE_SIZE === 0); |
| Module['wasmMemory'] = new WebAssembly.Memory({ 'initial': TOTAL_MEMORY / WASM_PAGE_SIZE, 'maximum': TOTAL_MEMORY / WASM_PAGE_SIZE }); |
| buffer = Module['wasmMemory'].buffer; |
| } else |
| { |
| buffer = new ArrayBuffer(TOTAL_MEMORY); |
| } |
| assert(buffer.byteLength === TOTAL_MEMORY); |
| } |
| updateGlobalBufferViews(); |
| |
| |
| function getTotalMemory() { |
| return TOTAL_MEMORY; |
| } |
| |
| // Endianness check (note: assumes compiler arch was little-endian) |
| HEAP32[0] = 0x63736d65; /* 'emsc' */ |
| HEAP16[1] = 0x6373; |
| if (HEAPU8[2] !== 0x73 || HEAPU8[3] !== 0x63) throw 'Runtime error: expected the system to be little-endian!'; |
| |
| Module['HEAP'] = HEAP; |
| Module['buffer'] = buffer; |
| Module['HEAP8'] = HEAP8; |
| Module['HEAP16'] = HEAP16; |
| Module['HEAP32'] = HEAP32; |
| Module['HEAPU8'] = HEAPU8; |
| Module['HEAPU16'] = HEAPU16; |
| Module['HEAPU32'] = HEAPU32; |
| Module['HEAPF32'] = HEAPF32; |
| Module['HEAPF64'] = HEAPF64; |
| |
| 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 runtime has exited |
| |
| 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 ensureInitRuntime() { |
| checkStackCookie(); |
| if (runtimeInitialized) return; |
| runtimeInitialized = true; |
| callRuntimeCallbacks(__ATINIT__); |
| } |
| |
| function preMain() { |
| checkStackCookie(); |
| callRuntimeCallbacks(__ATMAIN__); |
| } |
| |
| function exitRuntime() { |
| checkStackCookie(); |
| callRuntimeCallbacks(__ATEXIT__); |
| runtimeExited = true; |
| } |
| |
| function postRun() { |
| checkStackCookie(); |
| // 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); |
| } |
| Module["addOnPreRun"] = addOnPreRun; |
| |
| function addOnInit(cb) { |
| __ATINIT__.unshift(cb); |
| } |
| Module["addOnInit"] = addOnInit; |
| |
| function addOnPreMain(cb) { |
| __ATMAIN__.unshift(cb); |
| } |
| Module["addOnPreMain"] = addOnPreMain; |
| |
| function addOnExit(cb) { |
| __ATEXIT__.unshift(cb); |
| } |
| Module["addOnExit"] = addOnExit; |
| |
| function addOnPostRun(cb) { |
| __ATPOSTRUN__.unshift(cb); |
| } |
| Module["addOnPostRun"] = addOnPostRun; |
| |
| // Tools |
| |
| |
| function intArrayFromString(stringy, dontAddNull, length /* optional */) { |
| 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; |
| } |
| Module["intArrayFromString"] = intArrayFromString; |
| |
| function intArrayToString(array) { |
| var ret = []; |
| for (var i = 0; i < array.length; i++) { |
| var chr = array[i]; |
| if (chr > 0xFF) { |
| 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(''); |
| } |
| Module["intArrayToString"] = intArrayToString; |
| |
| // 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. |
| function writeStringToMemory(string, buffer, dontAddNull) { |
| Runtime.warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!'); |
| |
| var lastChar, 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. |
| } |
| Module["writeStringToMemory"] = writeStringToMemory; |
| |
| function writeArrayToMemory(array, buffer) { |
| assert(array.length >= 0, 'writeArrayToMemory array must have a length (should be an array or typed array)') |
| HEAP8.set(array, buffer); |
| } |
| Module["writeArrayToMemory"] = writeArrayToMemory; |
| |
| function writeAsciiToMemory(str, buffer, dontAddNull) { |
| for (var i = 0; i < str.length; ++i) { |
| assert(str.charCodeAt(i) === str.charCodeAt(i)&0xff); |
| HEAP8[((buffer++)>>0)]=str.charCodeAt(i); |
| } |
| // Null-terminate the pointer to the HEAP. |
| if (!dontAddNull) HEAP8[((buffer)>>0)]=0; |
| } |
| Module["writeAsciiToMemory"] = writeAsciiToMemory; |
| |
| 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; |
| } |
| |
| |
| // check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 ) |
| if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) { |
| var ah = a >>> 16; |
| var al = a & 0xffff; |
| var bh = b >>> 16; |
| var bl = b & 0xffff; |
| return (al*bl + ((ah*bl + al*bh) << 16))|0; |
| }; |
| Math.imul = Math['imul']; |
| |
| if (!Math['fround']) { |
| var froundBuffer = new Float32Array(1); |
| Math['fround'] = function(x) { froundBuffer[0] = x; return froundBuffer[0] }; |
| } |
| Math.fround = Math['fround']; |
| |
| if (!Math['clz32']) Math['clz32'] = function(x) { |
| x = x >>> 0; |
| for (var i = 0; i < 32; i++) { |
| if (x & (1 << (31 - i))) return i; |
| } |
| return 32; |
| }; |
| Math.clz32 = Math['clz32'] |
| |
| if (!Math['trunc']) Math['trunc'] = function(x) { |
| return x < 0 ? Math.ceil(x) : Math.floor(x); |
| }; |
| Math.trunc = Math['trunc']; |
| |
| 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_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 |
| // PRE_RUN_ADDITIONS (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 |
| var runDependencyTracking = {}; |
| |
| function getUniqueRunDependency(id) { |
| var orig = id; |
| while (1) { |
| if (!runDependencyTracking[id]) return id; |
| id = orig + Math.random(); |
| } |
| return id; |
| } |
| |
| function addRunDependency(id) { |
| runDependencies++; |
| if (Module['monitorRunDependencies']) { |
| Module['monitorRunDependencies'](runDependencies); |
| } |
| if (id) { |
| assert(!runDependencyTracking[id]); |
| runDependencyTracking[id] = 1; |
| if (runDependencyWatcher === null && typeof setInterval !== 'undefined') { |
| // Check for missing dependencies every few seconds |
| runDependencyWatcher = setInterval(function() { |
| if (ABORT) { |
| clearInterval(runDependencyWatcher); |
| runDependencyWatcher = null; |
| return; |
| } |
| var shown = false; |
| for (var dep in runDependencyTracking) { |
| if (!shown) { |
| shown = true; |
| Module.printErr('still waiting on run dependencies:'); |
| } |
| Module.printErr('dependency: ' + dep); |
| } |
| if (shown) { |
| Module.printErr('(end of list)'); |
| } |
| }, 10000); |
| } |
| } else { |
| Module.printErr('warning: run dependency added without ID'); |
| } |
| } |
| Module["addRunDependency"] = addRunDependency; |
| |
| function removeRunDependency(id) { |
| runDependencies--; |
| if (Module['monitorRunDependencies']) { |
| Module['monitorRunDependencies'](runDependencies); |
| } |
| if (id) { |
| assert(runDependencyTracking[id]); |
| delete runDependencyTracking[id]; |
| } else { |
| Module.printErr('warning: run dependency removed without ID'); |
| } |
| if (runDependencies == 0) { |
| if (runDependencyWatcher !== null) { |
| clearInterval(runDependencyWatcher); |
| runDependencyWatcher = null; |
| } |
| if (dependenciesFulfilled) { |
| var callback = dependenciesFulfilled; |
| dependenciesFulfilled = null; |
| callback(); // can add another dependenciesFulfilled |
| } |
| } |
| } |
| Module["removeRunDependency"] = removeRunDependency; |
| |
| Module["preloadedImages"] = {}; // maps url to image data |
| Module["preloadedAudios"] = {}; // maps url to audio data |
| |
| |
| |
| var memoryInitializer = null; |
| |
| |
| |
| var /* show errors on likely calls to FS when it was not included */ FS = { |
| error: function() { |
| abort('Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -s FORCE_FILESYSTEM=1'); |
| }, |
| init: function() { FS.error() }, |
| createDataFile: function() { FS.error() }, |
| createPreloadedFile: function() { FS.error() }, |
| createLazyFile: function() { FS.error() }, |
| open: function() { FS.error() }, |
| mkdev: function() { FS.error() }, |
| registerDevice: function() { FS.error() }, |
| analyzePath: function() { FS.error() }, |
| loadFilesFromDB: function() { FS.error() }, |
| |
| ErrnoError: function ErrnoError() { FS.error() }, |
| }; |
| Module['FS_createDataFile'] = FS.createDataFile; |
| Module['FS_createPreloadedFile'] = FS.createPreloadedFile; |
| |
| |
| function integrateWasmJS(Module) { |
| // wasm.js has several methods for creating the compiled code module here: |
| // * 'native-wasm' : use native WebAssembly support in the browser |
| // * 'interpret-s-expr': load s-expression code from a .wast and interpret |
| // * 'interpret-binary': load binary wasm and interpret |
| // * 'interpret-asm2wasm': load asm.js code, translate to wasm, and interpret |
| // * 'asmjs': no wasm, just load the asm.js code and use that (good for testing) |
| // The method can be set at compile time (BINARYEN_METHOD), or runtime by setting Module['wasmJSMethod']. |
| // The method can be a comma-separated list, in which case, we will try the |
| // options one by one. Some of them can fail gracefully, and then we can try |
| // the next. |
| |
| // inputs |
| |
| var method = Module['wasmJSMethod'] || 'native-wasm'; |
| Module['wasmJSMethod'] = method; |
| |
| var wasmTextFile = Module['wasmTextFile'] || 'test6.wast'; |
| var wasmBinaryFile = Module['wasmBinaryFile'] || 'test6.wasm'; |
| var asmjsCodeFile = Module['asmjsCodeFile'] || 'test6.temp.asm.js'; |
| |
| // utilities |
| |
| var wasmPageSize = 64*1024; |
| |
| var asm2wasmImports = { // special asm2wasm imports |
| "f64-rem": function(x, y) { |
| return x % y; |
| }, |
| "f64-to-int": function(x) { |
| return x | 0; |
| }, |
| "i32s-div": function(x, y) { |
| return ((x | 0) / (y | 0)) | 0; |
| }, |
| "i32u-div": function(x, y) { |
| return ((x >>> 0) / (y >>> 0)) >>> 0; |
| }, |
| "i32s-rem": function(x, y) { |
| return ((x | 0) % (y | 0)) | 0; |
| }, |
| "i32u-rem": function(x, y) { |
| return ((x >>> 0) % (y >>> 0)) >>> 0; |
| }, |
| "debugger": function() { |
| debugger; |
| }, |
| }; |
| |
| var info = { |
| 'global': null, |
| 'env': null, |
| 'asm2wasm': asm2wasmImports, |
| 'parent': Module // Module inside wasm-js.cpp refers to wasm-js.cpp; this allows access to the outside program. |
| }; |
| |
| var exports = null; |
| |
| function lookupImport(mod, base) { |
| var lookup = info; |
| if (mod.indexOf('.') < 0) { |
| lookup = (lookup || {})[mod]; |
| } else { |
| var parts = mod.split('.'); |
| lookup = (lookup || {})[parts[0]]; |
| lookup = (lookup || {})[parts[1]]; |
| } |
| if (base) { |
| lookup = (lookup || {})[base]; |
| } |
| if (lookup === undefined) { |
| abort('bad lookupImport to (' + mod + ').' + base); |
| } |
| return lookup; |
| } |
| |
| function mergeMemory(newBuffer) { |
| // The wasm instance creates its memory. But static init code might have written to |
| // buffer already, including the mem init file, and we must copy it over in a proper merge. |
| // TODO: avoid this copy, by avoiding such static init writes |
| // TODO: in shorter term, just copy up to the last static init write |
| var oldBuffer = Module['buffer']; |
| if (newBuffer.byteLength < oldBuffer.byteLength) { |
| Module['printErr']('the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here'); |
| } |
| var oldView = new Int8Array(oldBuffer); |
| var newView = new Int8Array(newBuffer); |
| |
| // If we have a mem init file, do not trample it |
| if (!memoryInitializer) { |
| oldView.set(newView.subarray(Module['STATIC_BASE'], Module['STATIC_BASE'] + Module['STATIC_BUMP']), Module['STATIC_BASE']); |
| } |
| |
| newView.set(oldView); |
| updateGlobalBuffer(newBuffer); |
| updateGlobalBufferViews(); |
| } |
| |
| var WasmTypes = { |
| none: 0, |
| i32: 1, |
| i64: 2, |
| f32: 3, |
| f64: 4 |
| }; |
| |
| function fixImports(imports) { |
| if (!0) return imports; |
| var ret = {}; |
| for (var i in imports) { |
| var fixed = i; |
| if (fixed[0] == '_') fixed = fixed.substr(1); |
| ret[fixed] = imports[i]; |
| } |
| return ret; |
| } |
| |
| function getBinary() { |
| var binary; |
| if (Module['wasmBinary']) { |
| binary = Module['wasmBinary']; |
| binary = new Uint8Array(binary); |
| } else if (Module['readBinary']) { |
| binary = Module['readBinary'](wasmBinaryFile); |
| } else { |
| throw "on the web, we need the wasm binary to be preloaded and set on Module['wasmBinary']. emcc.py will do that for you when generating HTML (but not JS)"; |
| } |
| return binary; |
| } |
| |
| function getBinaryPromise() { |
| // if we don't have the binary yet, and have the Fetch api, use that |
| if (!Module['wasmBinary'] && typeof fetch === 'function') { |
| return fetch(wasmBinaryFile).then(function(response) { return response['arrayBuffer']() }); |
| } |
| // Otherwise, getBinary should be able to get it synchronously |
| return new Promise(function(resolve, reject) { |
| resolve(getBinary()); |
| }); |
| } |
| |
| // do-method functions |
| |
| function doJustAsm(global, env, providedBuffer) { |
| // if no Module.asm, or it's the method handler helper (see below), then apply |
| // the asmjs |
| if (typeof Module['asm'] !== 'function' || Module['asm'] === methodHandler) { |
| if (!Module['asmPreload']) { |
| // you can load the .asm.js file before this, to avoid this sync xhr and eval |
| eval(Module['read'](asmjsCodeFile)); // set Module.asm |
| } else { |
| Module['asm'] = Module['asmPreload']; |
| } |
| } |
| if (typeof Module['asm'] !== 'function') { |
| Module['printErr']('asm evalling did not set the module properly'); |
| return false; |
| } |
| return Module['asm'](global, env, providedBuffer); |
| } |
| |
| function doNativeWasm(global, env, providedBuffer) { |
| if (typeof WebAssembly !== 'object') { |
| Module['printErr']('no native wasm support detected'); |
| return false; |
| } |
| // prepare memory import |
| if (!(Module['wasmMemory'] instanceof WebAssembly.Memory)) { |
| Module['printErr']('no native wasm Memory in use'); |
| return false; |
| } |
| env['memory'] = Module['wasmMemory']; |
| // Load the wasm module and create an instance of using native support in the JS engine. |
| info['global'] = { |
| 'NaN': NaN, |
| 'Infinity': Infinity |
| }; |
| info['global.Math'] = global.Math; |
| info['env'] = env; |
| // handle a generated wasm instance, receiving its exports and |
| // performing other necessary setup |
| function receiveInstance(instance) { |
| exports = instance.exports; |
| if (exports.memory) mergeMemory(exports.memory); |
| Module['asm'] = exports; |
| Module["usingWasm"] = true; |
| removeRunDependency('wasm-instantiate'); |
| } |
| |
| addRunDependency('wasm-instantiate'); // we can't run yet |
| |
| // 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 { |
| return Module['instantiateWasm'](info, receiveInstance); |
| } catch(e) { |
| Module['printErr']('Module.instantiateWasm callback failed with error: ' + e); |
| return false; |
| } |
| } |
| |
| Module['printErr']('asynchronously preparing wasm'); |
| getBinaryPromise().then(function(binary) { |
| return WebAssembly.instantiate(binary, info) |
| }).then(function(output) { |
| // receiveInstance() will swap in the exports (to Module.asm) so they can be called |
| receiveInstance(output['instance']); |
| }).catch(function(reason) { |
| Module['printErr']('failed to asynchronously prepare wasm: ' + reason); |
| Module['quit'](1, reason); |
| }); |
| return {}; // no exports yet; we'll fill them in later |
| } |
| |
| function doWasmPolyfill(global, env, providedBuffer, method) { |
| if (typeof WasmJS !== 'function') { |
| Module['printErr']('WasmJS not detected - polyfill not bundled?'); |
| return false; |
| } |
| |
| // Use wasm.js to polyfill and execute code in a wasm interpreter. |
| var wasmJS = WasmJS({}); |
| |
| // XXX don't be confused. Module here is in the outside program. wasmJS is the inner wasm-js.cpp. |
| wasmJS['outside'] = Module; // Inside wasm-js.cpp, Module['outside'] reaches the outside module. |
| |
| // Information for the instance of the module. |
| wasmJS['info'] = info; |
| |
| wasmJS['lookupImport'] = lookupImport; |
| |
| assert(providedBuffer === Module['buffer']); // we should not even need to pass it as a 3rd arg for wasm, but that's the asm.js way. |
| |
| info.global = global; |
| info.env = env; |
| |
| // polyfill interpreter expects an ArrayBuffer |
| assert(providedBuffer === Module['buffer']); |
| env['memory'] = providedBuffer; |
| assert(env['memory'] instanceof ArrayBuffer); |
| |
| wasmJS['providedTotalMemory'] = Module['buffer'].byteLength; |
| |
| // Prepare to generate wasm, using either asm2wasm or s-exprs |
| var code; |
| if (method === 'interpret-binary') { |
| code = getBinary(); |
| } else { |
| code = Module['read'](method == 'interpret-asm2wasm' ? asmjsCodeFile : wasmTextFile); |
| } |
| var temp; |
| if (method == 'interpret-asm2wasm') { |
| temp = wasmJS['_malloc'](code.length + 1); |
| wasmJS['writeAsciiToMemory'](code, temp); |
| wasmJS['_load_asm2wasm'](temp); |
| } else if (method === 'interpret-s-expr') { |
| temp = wasmJS['_malloc'](code.length + 1); |
| wasmJS['writeAsciiToMemory'](code, temp); |
| wasmJS['_load_s_expr2wasm'](temp); |
| } else if (method === 'interpret-binary') { |
| temp = wasmJS['_malloc'](code.length); |
| wasmJS['HEAPU8'].set(code, temp); |
| wasmJS['_load_binary2wasm'](temp, code.length); |
| } else { |
| throw 'what? ' + method; |
| } |
| wasmJS['_free'](temp); |
| |
| wasmJS['_instantiate'](temp); |
| |
| if (Module['newBuffer']) { |
| mergeMemory(Module['newBuffer']); |
| Module['newBuffer'] = null; |
| } |
| |
| exports = wasmJS['asmExports']; |
| |
| return exports; |
| } |
| |
| // We may have a preloaded value in Module.asm, save it |
| Module['asmPreload'] = Module['asm']; |
| |
| // Memory growth integration code |
| Module['reallocBuffer'] = function(size) { |
| var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE; // In wasm, heap size must be a multiple of 64KB. In asm.js, they need to be multiples of 16MB. |
| size = alignUp(size, PAGE_MULTIPLE); // round up to wasm page size |
| var old = Module['buffer']; |
| var oldSize = old.byteLength; |
| if (Module["usingWasm"]) { |
| try { |
| var result = Module['wasmMemory'].grow((size - oldSize) / wasmPageSize); // .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 |
| return Module['buffer'] = Module['wasmMemory'].buffer; |
| } else { |
| return null; |
| } |
| } catch(e) { |
| console.error('Module.reallocBuffer: Attempted to grow from ' + oldSize + ' bytes to ' + size + ' bytes, but got error: ' + e); |
| return null; |
| } |
| } else { |
| exports['__growWasmMemory']((size - oldSize) / wasmPageSize); // tiny wasm method that just does grow_memory |
| // in interpreter, we replace Module.buffer if we allocate |
| return Module['buffer'] !== old ? Module['buffer'] : null; // if it was reallocated, it changed |
| } |
| }; |
| |
| // 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 olyfilled wasm or asm.js. |
| |
| Module['asm'] = function(global, env, providedBuffer) { |
| global = fixImports(global); |
| env = fixImports(env); |
| |
| // import table |
| if (!env['table']) { |
| var TABLE_SIZE = Module['wasmTableSize']; |
| if (TABLE_SIZE === undefined) TABLE_SIZE = 1024; // works in binaryen interpreter at least |
| var MAX_TABLE_SIZE = Module['wasmMaxTableSize']; |
| if (typeof WebAssembly === 'object' && typeof WebAssembly.Table === 'function') { |
| if (MAX_TABLE_SIZE !== undefined) { |
| env['table'] = new WebAssembly.Table({ 'initial': TABLE_SIZE, 'maximum': MAX_TABLE_SIZE, 'element': 'anyfunc' }); |
| } else { |
| env['table'] = new WebAssembly.Table({ 'initial': TABLE_SIZE, element: 'anyfunc' }); |
| } |
| } else { |
| env['table'] = new Array(TABLE_SIZE); // works in binaryen interpreter at least |
| } |
| Module['wasmTable'] = env['table']; |
| } |
| |
| if (!env['memoryBase']) { |
| env['memoryBase'] = Module['STATIC_BASE']; // tell the memory segments where to place themselves |
| } |
| if (!env['tableBase']) { |
| env['tableBase'] = 0; // table starts at 0 by default, in dynamic linking this will change |
| } |
| |
| // try the methods. each should return the exports if it succeeded |
| |
| var exports; |
| var methods = method.split(','); |
| |
| for (var i = 0; i < methods.length; i++) { |
| var curr = methods[i]; |
| |
| Module['printErr']('trying binaryen method: ' + curr); |
| |
| if (curr === 'native-wasm') { |
| if (exports = doNativeWasm(global, env, providedBuffer)) break; |
| } else if (curr === 'asmjs') { |
| if (exports = doJustAsm(global, env, providedBuffer)) break; |
| } else if (curr === 'interpret-asm2wasm' || curr === 'interpret-s-expr' || curr === 'interpret-binary') { |
| if (exports = doWasmPolyfill(global, env, providedBuffer, curr)) break; |
| } else { |
| throw 'bad method: ' + curr; |
| } |
| } |
| |
| if (!exports) throw 'no binaryen method succeeded. consider enabling more options, like interpreting, if you want that: https://github.com/kripken/emscripten/wiki/WebAssembly#binaryen-methods'; |
| |
| Module['printErr']('binaryen method succeeded.'); |
| |
| return exports; |
| }; |
| |
| var methodHandler = Module['asm']; // note our method handler, as we may modify Module['asm'] later |
| } |
| |
| integrateWasmJS(Module); |
| |
| // === Body === |
| |
| var ASM_CONSTS = []; |
| |
| |
| |
| |
| STATIC_BASE = Runtime.GLOBAL_BASE; |
| |
| STATICTOP = STATIC_BASE + 1840; |
| /* global initializers */ __ATINIT__.push(); |
| |
| |
| memoryInitializer = Module["wasmJSMethod"].indexOf("asmjs") >= 0 || Module["wasmJSMethod"].indexOf("interpret-asm2wasm") >= 0 ? "test6.js.mem" : null; |
| |
| |
| |
| |
| var STATIC_BUMP = 1840; |
| Module["STATIC_BASE"] = STATIC_BASE; |
| Module["STATIC_BUMP"] = STATIC_BUMP; |
| |
| /* no memory initializer */ |
| var tempDoublePtr = STATICTOP; STATICTOP += 16; |
| |
| assert(tempDoublePtr % 8 == 0); |
| |
| 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 _abort() { |
| Module['abort'](); |
| } |
| |
| |
| function ___setErrNo(value) { |
| if (Module['___errno_location']) HEAP32[((Module['___errno_location']())>>2)]=value; |
| else Module.printErr('failed to set errno from JS'); |
| return value; |
| } |
| Module["_sbrk"] = _sbrk; |
| DYNAMICTOP_PTR = allocate(1, "i32", ALLOC_STATIC); |
| |
| STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP); |
| |
| STACK_MAX = STACK_BASE + TOTAL_STACK; |
| |
| DYNAMIC_BASE = Runtime.alignMemory(STACK_MAX); |
| |
| HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE; |
| |
| staticSealed = true; // seal the static portion of memory |
| |
| assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack"); |
| |
| |
| |
| Module['wasmTableSize'] = 0; |
| |
| Module['wasmMaxTableSize'] = 0; |
| |
| Module.asmGlobalArg = { "Math": Math, "Int8Array": Int8Array, "Int16Array": Int16Array, "Int32Array": Int32Array, "Uint8Array": Uint8Array, "Uint16Array": Uint16Array, "Uint32Array": Uint32Array, "Float32Array": Float32Array, "Float64Array": Float64Array, "NaN": NaN, "Infinity": Infinity }; |
| |
| Module.asmLibraryArg = { "abort": abort, "assert": assert, "enlargeMemory": enlargeMemory, "getTotalMemory": getTotalMemory, "abortOnCannotGrowMemory": abortOnCannotGrowMemory, "abortStackOverflow": abortStackOverflow, "_abort": _abort, "___setErrNo": ___setErrNo, "DYNAMICTOP_PTR": DYNAMICTOP_PTR, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX }; |
| // EMSCRIPTEN_START_ASM |
| var asm =Module["asm"]// EMSCRIPTEN_END_ASM |
| (Module.asmGlobalArg, Module.asmLibraryArg, buffer); |
| |
| var real__sbrk = asm["_sbrk"]; asm["_sbrk"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real__sbrk.apply(null, arguments); |
| }; |
| |
| var real_getTempRet0 = asm["getTempRet0"]; asm["getTempRet0"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real_getTempRet0.apply(null, arguments); |
| }; |
| |
| var real__free = asm["_free"]; asm["_free"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real__free.apply(null, arguments); |
| }; |
| |
| var real_setTempRet0 = asm["setTempRet0"]; asm["setTempRet0"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real_setTempRet0.apply(null, arguments); |
| }; |
| |
| var real_establishStackSpace = asm["establishStackSpace"]; asm["establishStackSpace"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real_establishStackSpace.apply(null, arguments); |
| }; |
| |
| var real_stackRestore = asm["stackRestore"]; asm["stackRestore"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real_stackRestore.apply(null, arguments); |
| }; |
| |
| var real__malloc = asm["_malloc"]; asm["_malloc"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real__malloc.apply(null, arguments); |
| }; |
| |
| var real__emscripten_get_global_libc = asm["_emscripten_get_global_libc"]; asm["_emscripten_get_global_libc"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real__emscripten_get_global_libc.apply(null, arguments); |
| }; |
| |
| var real_stackAlloc = asm["stackAlloc"]; asm["stackAlloc"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real_stackAlloc.apply(null, arguments); |
| }; |
| |
| var real_setThrew = asm["setThrew"]; asm["setThrew"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real_setThrew.apply(null, arguments); |
| }; |
| |
| var real__hello_world = asm["_hello_world"]; asm["_hello_world"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real__hello_world.apply(null, arguments); |
| }; |
| |
| var real_stackSave = asm["stackSave"]; asm["stackSave"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real_stackSave.apply(null, arguments); |
| }; |
| Module["asm"] = asm; |
| var _sbrk = Module["_sbrk"] = function() { return Module["asm"]["_sbrk"].apply(null, arguments) }; |
| var getTempRet0 = Module["getTempRet0"] = function() { return Module["asm"]["getTempRet0"].apply(null, arguments) }; |
| var _free = Module["_free"] = function() { return Module["asm"]["_free"].apply(null, arguments) }; |
| var runPostSets = Module["runPostSets"] = function() { return Module["asm"]["runPostSets"].apply(null, arguments) }; |
| var setTempRet0 = Module["setTempRet0"] = function() { return Module["asm"]["setTempRet0"].apply(null, arguments) }; |
| var establishStackSpace = Module["establishStackSpace"] = function() { return Module["asm"]["establishStackSpace"].apply(null, arguments) }; |
| var stackRestore = Module["stackRestore"] = function() { return Module["asm"]["stackRestore"].apply(null, arguments) }; |
| var _malloc = Module["_malloc"] = function() { return Module["asm"]["_malloc"].apply(null, arguments) }; |
| var _emscripten_get_global_libc = Module["_emscripten_get_global_libc"] = function() { return Module["asm"]["_emscripten_get_global_libc"].apply(null, arguments) }; |
| var stackAlloc = Module["stackAlloc"] = function() { return Module["asm"]["stackAlloc"].apply(null, arguments) }; |
| var setThrew = Module["setThrew"] = function() { return Module["asm"]["setThrew"].apply(null, arguments) }; |
| var _hello_world = Module["_hello_world"] = function() { return Module["asm"]["_hello_world"].apply(null, arguments) }; |
| var stackSave = Module["stackSave"] = function() { return Module["asm"]["stackSave"].apply(null, arguments) }; |
| ; |
| |
| Runtime.stackAlloc = Module['stackAlloc']; |
| Runtime.stackSave = Module['stackSave']; |
| Runtime.stackRestore = Module['stackRestore']; |
| Runtime.establishStackSpace = Module['establishStackSpace']; |
| |
| Runtime.setTempRet0 = Module['setTempRet0']; |
| Runtime.getTempRet0 = Module['getTempRet0']; |
| |
| |
| |
| // === Auto-generated postamble setup entry stuff === |
| |
| Module['asm'] = asm; |
| |
| |
| |
| if (memoryInitializer) { |
| if (typeof Module['locateFile'] === 'function') { |
| memoryInitializer = Module['locateFile'](memoryInitializer); |
| } else if (Module['memoryInitializerPrefixURL']) { |
| memoryInitializer = Module['memoryInitializerPrefixURL'] + memoryInitializer; |
| } |
| if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) { |
| var data = Module['readBinary'](memoryInitializer); |
| HEAPU8.set(data, Runtime.GLOBAL_BASE); |
| } else { |
| addRunDependency('memory initializer'); |
| var applyMemoryInitializer = function(data) { |
| if (data.byteLength) data = new Uint8Array(data); |
| for (var i = 0; i < data.length; i++) { |
| assert(HEAPU8[Runtime.GLOBAL_BASE + i] === 0, "area for memory initializer should not have been touched before it's loaded"); |
| } |
| HEAPU8.set(data, Runtime.GLOBAL_BASE); |
| // Delete the typed array that contains the large blob of the memory initializer request response so that |
| // we won't keep unnecessary memory lying around. However, keep the XHR object itself alive so that e.g. |
| // its .status field can still be accessed later. |
| if (Module['memoryInitializerRequest']) delete Module['memoryInitializerRequest'].response; |
| removeRunDependency('memory initializer'); |
| } |
| function doBrowserLoad() { |
| Module['readAsync'](memoryInitializer, applyMemoryInitializer, function() { |
| throw 'could not load memory initializer ' + memoryInitializer; |
| }); |
| } |
| if (Module['memoryInitializerRequest']) { |
| // a network request has already been created, just use that |
| function useRequest() { |
| var request = Module['memoryInitializerRequest']; |
| if (request.status !== 200 && request.status !== 0) { |
| // If you see this warning, the issue may be that you are using locateFile or memoryInitializerPrefixURL, and defining them in JS. That |
| // means that the HTML file doesn't know about them, and when it tries to create the mem init request early, does it to the wrong place. |
| // Look in your browser's devtools network console to see what's going on. |
| console.warn('a problem seems to have happened with Module.memoryInitializerRequest, status: ' + request.status + ', retrying ' + memoryInitializer); |
| doBrowserLoad(); |
| return; |
| } |
| applyMemoryInitializer(request.response); |
| } |
| if (Module['memoryInitializerRequest'].response) { |
| setTimeout(useRequest, 0); // it's already here; but, apply it asynchronously |
| } else { |
| Module['memoryInitializerRequest'].addEventListener('load', useRequest); // wait for it |
| } |
| } else { |
| // fetch it from the network ourselves |
| doBrowserLoad(); |
| } |
| } |
| } |
| |
| |
| |
| 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 initialStackTop; |
| var preloadStartTime = null; |
| 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 |
| } |
| |
| Module['callMain'] = Module.callMain = function callMain(args) { |
| assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)'); |
| assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called'); |
| |
| args = args || []; |
| |
| ensureInitRuntime(); |
| |
| var argc = args.length+1; |
| function pad() { |
| for (var i = 0; i < 4-1; i++) { |
| argv.push(0); |
| } |
| } |
| var argv = [allocate(intArrayFromString(Module['thisProgram']), 'i8', ALLOC_NORMAL) ]; |
| pad(); |
| for (var i = 0; i < argc-1; i = i + 1) { |
| argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL)); |
| pad(); |
| } |
| argv.push(0); |
| argv = allocate(argv, 'i32', ALLOC_NORMAL); |
| |
| |
| try { |
| |
| var ret = Module['_main'](argc, argv, 0); |
| |
| |
| // if we're not running an evented main loop, it's time to exit |
| exit(ret, /* implicit = */ true); |
| } |
| catch(e) { |
| if (e instanceof ExitStatus) { |
| // exit() throws this once it's done to make sure execution |
| // has been stopped completely |
| return; |
| } else if (e == 'SimulateInfiniteLoop') { |
| // running an evented main loop, don't immediately exit |
| Module['noExitRuntime'] = true; |
| return; |
| } else { |
| var toLog = e; |
| if (e && typeof e === 'object' && e.stack) { |
| toLog = [e, e.stack]; |
| } |
| Module.printErr('exception thrown: ' + toLog); |
| Module['quit'](1, e); |
| } |
| } finally { |
| calledMain = true; |
| } |
| } |
| |
| |
| |
| |
| function run(args) { |
| args = args || Module['arguments']; |
| |
| if (preloadStartTime === null) preloadStartTime = Date.now(); |
| |
| if (runDependencies > 0) { |
| Module.printErr('run() called, but dependencies remain, so not running'); |
| return; |
| } |
| |
| writeStackCookie(); |
| |
| 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; |
| |
| ensureInitRuntime(); |
| |
| preMain(); |
| |
| if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) { |
| Module.printErr('pre-main prep time: ' + (Date.now() - preloadStartTime) + ' ms'); |
| } |
| |
| if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); |
| |
| if (Module['_main'] && shouldRunNow) Module['callMain'](args); |
| |
| postRun(); |
| } |
| |
| if (Module['setStatus']) { |
| Module['setStatus']('Running...'); |
| setTimeout(function() { |
| setTimeout(function() { |
| Module['setStatus'](''); |
| }, 1); |
| doRun(); |
| }, 1); |
| } else { |
| doRun(); |
| } |
| checkStackCookie(); |
| } |
| Module['run'] = Module.run = run; |
| |
| function exit(status, implicit) { |
| if (implicit && Module['noExitRuntime']) { |
| Module.printErr('exit(' + status + ') implicitly called by end of main(), but noExitRuntime, so not exiting the runtime (you can use emscripten_force_exit, if you want to force a true shutdown)'); |
| return; |
| } |
| |
| if (Module['noExitRuntime']) { |
| Module.printErr('exit(' + status + ') called, but noExitRuntime, so halting execution but not exiting the runtime or preventing further async execution (you can use emscripten_force_exit, if you want to force a true shutdown)'); |
| } else { |
| |
| ABORT = true; |
| EXITSTATUS = status; |
| STACKTOP = initialStackTop; |
| |
| exitRuntime(); |
| |
| if (Module['onExit']) Module['onExit'](status); |
| } |
| |
| if (ENVIRONMENT_IS_NODE) { |
| process['exit'](status); |
| } |
| Module['quit'](status, new ExitStatus(status)); |
| } |
| Module['exit'] = Module.exit = exit; |
| |
| var abortDecorators = []; |
| |
| function abort(what) { |
| if (what !== undefined) { |
| Module.print(what); |
| Module.printErr(what); |
| what = JSON.stringify(what) |
| } else { |
| what = ''; |
| } |
| |
| ABORT = true; |
| EXITSTATUS = 1; |
| |
| var extra = ''; |
| |
| var output = 'abort(' + what + ') at ' + stackTrace() + extra; |
| if (abortDecorators) { |
| abortDecorators.forEach(function(decorator) { |
| output = decorator(output, what); |
| }); |
| } |
| throw output; |
| } |
| Module['abort'] = Module.abort = abort; |
| |
| // {{PRE_RUN_ADDITIONS}} |
| |
| if (Module['preInit']) { |
| if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; |
| while (Module['preInit'].length > 0) { |
| Module['preInit'].pop()(); |
| } |
| } |
| |
| // shouldRunNow refers to calling main(), not run(). |
| var shouldRunNow = true; |
| if (Module['noInitialRun']) { |
| shouldRunNow = false; |
| } |
| |
| Module["noExitRuntime"] = true; |
| |
| run(); |
| |
| // {{POST_RUN_ADDITIONS}} |
| |
| |
| |
| |
| |
| // {{MODULE_ADDITIONS}} |
| |
| |
| |