Created
May 9, 2017 14:57
-
-
Save andrewkersten/9d18316e12ac5fd0df2b46c396f77222 to your computer and use it in GitHub Desktop.
Javascript glue generated by emscripten from a basic c to wasm compilation.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// 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 shell_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 shell_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 shell_read(url) { | |
var xhr = new XMLHttpRequest(); | |
xhr.open('GET', url, false); | |
xhr.send(null); | |
return xhr.responseText; | |
}; | |
if (ENVIRONMENT_IS_WORKER) { | |
Module['readBinary'] = function readBinary(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 shell_print(x) { | |
console.log(x); | |
}; | |
if (!Module['printErr']) Module['printErr'] = function shell_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; | |
/** @type {function(*, string=)} */ | |
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; | |
/** @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); | |
} | |
} | |
Module["setValue"] = setValue; | |
/** @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 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_* | |
/** @type {function((TypedArray|Array<number>|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 = [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(/** @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]; | |
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; | |
/** @type {function(number, number=)} */ | |
function Pointer_stringify(ptr, 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, | |
/** @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 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' && Int32Array.prototype.subarray !== undefined && Int32Array.prototype.set !== undefined, | |
'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 | |
/** @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; | |
} | |
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. | |
/** @deprecated */ | |
function writeStringToMemory(string, buffer, dontAddNull) { | |
Runtime.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. | |
} | |
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'] || 'hello.wast'; | |
var wasmBinaryFile = Module['wasmBinaryFile'] || 'hello.wasm'; | |
var asmjsCodeFile = Module['asmjsCodeFile'] || 'hello.temp.asm.js'; | |
if (typeof Module['locateFile'] === 'function') { | |
wasmTextFile = Module['locateFile'](wasmTextFile); | |
wasmBinaryFile = Module['locateFile'](wasmBinaryFile); | |
asmjsCodeFile = Module['locateFile'](asmjsCodeFile); | |
} | |
// 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) { | |
if (!response['ok']) { | |
throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; | |
} | |
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; | |
} | |
} | |
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]; | |
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'; | |
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 + 3008; | |
/* global initializers */ __ATINIT__.push(); | |
memoryInitializer = Module["wasmJSMethod"].indexOf("asmjs") >= 0 || Module["wasmJSMethod"].indexOf("interpret-asm2wasm") >= 0 ? "hello.html.mem" : null; | |
var STATIC_BUMP = 3008; | |
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 ___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; | |
Module["_memset"] = _memset; | |
function ___lock() {} | |
function _emscripten_memcpy_big(dest, src, num) { | |
HEAPU8.set(HEAPU8.subarray(src, src+num), dest); | |
return dest; | |
} | |
Module["_memcpy"] = _memcpy; | |
function _abort() { | |
Module['abort'](); | |
} | |
var SYSCALLS={varargs:0,get:function (varargs) { | |
SYSCALLS.varargs += 4; | |
var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)]; | |
return ret; | |
},getStr:function () { | |
var ret = Pointer_stringify(SYSCALLS.get()); | |
return ret; | |
},get64:function () { | |
var low = SYSCALLS.get(), high = SYSCALLS.get(); | |
if (low >= 0) assert(high === 0); | |
else assert(high === -1); | |
return low; | |
},getZero:function () { | |
assert(SYSCALLS.get() === 0); | |
}};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(); | |
var offset = offset_low; | |
assert(offset_high === 0); | |
FS.llseek(stream, offset, whence); | |
HEAP32[((result)>>2)]=stream.position; | |
if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state | |
return 0; | |
} catch (e) { | |
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); | |
return -e.errno; | |
} | |
} | |
function ___syscall146(which, varargs) {SYSCALLS.varargs = varargs; | |
try { | |
// writev | |
// hack to support printf in NO_FILESYSTEM | |
var stream = SYSCALLS.get(), iov = SYSCALLS.get(), iovcnt = SYSCALLS.get(); | |
var ret = 0; | |
if (!___syscall146.buffer) { | |
___syscall146.buffers = [null, [], []]; // 1 => stdout, 2 => stderr | |
___syscall146.printChar = function(stream, curr) { | |
var buffer = ___syscall146.buffers[stream]; | |
assert(buffer); | |
if (curr === 0 || curr === 10) { | |
(stream === 1 ? Module['print'] : Module['printErr'])(UTF8ArrayToString(buffer, 0)); | |
buffer.length = 0; | |
} else { | |
buffer.push(curr); | |
} | |
}; | |
} | |
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++) { | |
___syscall146.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 ___unlock() {} | |
function ___syscall6(which, varargs) {SYSCALLS.varargs = varargs; | |
try { | |
// close | |
var stream = SYSCALLS.getStreamFromFD(); | |
FS.close(stream); | |
return 0; | |
} catch (e) { | |
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); | |
return -e.errno; | |
} | |
} | |
/* flush anything remaining in the buffer during shutdown */ __ATEXIT__.push(function() { var fflush = Module["_fflush"]; if (fflush) fflush(0); var printChar = ___syscall146.printChar; if (!printChar) return; var buffers = ___syscall146.buffers; if (buffers[1].length) printChar(1, 10); if (buffers[2].length) printChar(2, 10); });; | |
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"); | |
function nullFunc_ii(x) { Module["printErr"]("Invalid function pointer called with signature 'ii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)"); Module["printErr"]("Build with ASSERTIONS=2 for more info.");abort(x) } | |
function nullFunc_iiii(x) { Module["printErr"]("Invalid function pointer called with signature 'iiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)"); Module["printErr"]("Build with ASSERTIONS=2 for more info.");abort(x) } | |
Module['wasmTableSize'] = 10; | |
Module['wasmMaxTableSize'] = 10; | |
function invoke_ii(index,a1) { | |
try { | |
return Module["dynCall_ii"](index,a1); | |
} catch(e) { | |
if (typeof e !== 'number' && e !== 'longjmp') throw e; | |
Module["setThrew"](1, 0); | |
} | |
} | |
function invoke_iiii(index,a1,a2,a3) { | |
try { | |
return Module["dynCall_iiii"](index,a1,a2,a3); | |
} catch(e) { | |
if (typeof e !== 'number' && e !== 'longjmp') throw e; | |
Module["setThrew"](1, 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, "nullFunc_ii": nullFunc_ii, "nullFunc_iiii": nullFunc_iiii, "invoke_ii": invoke_ii, "invoke_iiii": invoke_iiii, "___lock": ___lock, "___syscall6": ___syscall6, "___setErrNo": ___setErrNo, "_abort": _abort, "___syscall140": ___syscall140, "_emscripten_memcpy_big": _emscripten_memcpy_big, "___syscall54": ___syscall54, "___unlock": ___unlock, "___syscall146": ___syscall146, "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__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_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_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); | |
}; | |
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__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__fflush = asm["_fflush"]; asm["_fflush"] = 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__fflush.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____errno_location = asm["___errno_location"]; asm["___errno_location"] = 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____errno_location.apply(null, arguments); | |
}; | |
Module["asm"] = asm; | |
var _malloc = Module["_malloc"] = function() { return Module["asm"]["_malloc"].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 stackSave = Module["stackSave"] = function() { return Module["asm"]["stackSave"].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 _emscripten_get_global_libc = Module["_emscripten_get_global_libc"] = function() { return Module["asm"]["_emscripten_get_global_libc"].apply(null, arguments) }; | |
var _memcpy = Module["_memcpy"] = function() { return Module["asm"]["_memcpy"].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 _fflush = Module["_fflush"] = function() { return Module["asm"]["_fflush"].apply(null, arguments) }; | |
var stackRestore = Module["stackRestore"] = function() { return Module["asm"]["stackRestore"].apply(null, arguments) }; | |
var ___errno_location = Module["___errno_location"] = function() { return Module["asm"]["___errno_location"].apply(null, arguments) }; | |
var dynCall_ii = Module["dynCall_ii"] = function() { return Module["asm"]["dynCall_ii"].apply(null, arguments) }; | |
var dynCall_iiii = Module["dynCall_iiii"] = function() { return Module["asm"]["dynCall_iiii"].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(); | |
} | |
} | |
} | |
/** | |
* @constructor | |
* @extends {Error} | |
*/ | |
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; | |
} | |
} | |
/** @type {function(Array=)} */ | |
function run(args) { | |
args = args || Module['arguments']; | |
if (preloadStartTime === null) preloadStartTime = Date.now(); | |
if (runDependencies > 0) { | |
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; | |
} | |
run(); | |
// {{POST_RUN_ADDITIONS}} | |
// {{MODULE_ADDITIONS}} | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment