You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8285 lines
322 KiB
JavaScript
8285 lines
322 KiB
JavaScript
// Copyright 2010 The Emscripten Authors. All rights reserved.
|
|
// Emscripten is available under two separate licenses, the MIT license and the
|
|
// University of Illinois/NCSA Open Source License. Both these licenses can be
|
|
// found in the LICENSE file.
|
|
|
|
// The Module object: Our interface to the outside world. We import
|
|
// and export values on it. There are various ways Module can be used:
|
|
// 1. Not defined. We create it here
|
|
// 2. A function parameter, function(Module) { ..generated code.. }
|
|
// 3. pre-run appended it, var Module = {}; ..generated code..
|
|
// 4. External script tag defines var Module.
|
|
// We need to check if Module already exists (e.g. case 3 above).
|
|
// Substitution will be replaced with actual code on later stage of the build,
|
|
// this way Closure Compiler will not mangle it (e.g. case 4. above).
|
|
// Note that if you want to run closure, and also to use Module
|
|
// after the generated code, you will need to define var Module = {};
|
|
// before the code. Then that object will be used in the code, and you
|
|
// can continue to use Module afterwards as well.
|
|
var Module = typeof Module !== 'undefined' ? Module : {};
|
|
|
|
// --pre-jses are emitted after the Module integration code, so that they can
|
|
// refer to Module (if they choose; they can also define Module)
|
|
// {{PRE_JSES}}
|
|
|
|
// Sometimes an existing Module object exists with properties
|
|
// meant to overwrite the default module functionality. Here
|
|
// we collect those properties and reapply _after_ we configure
|
|
// the current environment's defaults to avoid having to be so
|
|
// defensive during initialization.
|
|
var moduleOverrides = {};
|
|
var key;
|
|
for (key in Module) {
|
|
if (Module.hasOwnProperty(key)) {
|
|
moduleOverrides[key] = Module[key];
|
|
}
|
|
}
|
|
|
|
var arguments_ = [];
|
|
var thisProgram = './this.program';
|
|
var quit_ = function(status, toThrow) {
|
|
throw toThrow;
|
|
};
|
|
|
|
// Determine the runtime environment we are in. You can customize this by
|
|
// setting the ENVIRONMENT setting at compile time (see settings.js).
|
|
|
|
var ENVIRONMENT_IS_WEB = false;
|
|
var ENVIRONMENT_IS_WORKER = false;
|
|
var ENVIRONMENT_IS_NODE = false;
|
|
var ENVIRONMENT_HAS_NODE = false;
|
|
var ENVIRONMENT_IS_SHELL = false;
|
|
ENVIRONMENT_IS_WEB = typeof window === 'object';
|
|
ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
|
|
// A web environment like Electron.js can have Node enabled, so we must
|
|
// distinguish between Node-enabled environments and Node environments per se.
|
|
// This will allow the former to do things like mount NODEFS.
|
|
// Extended check using process.versions fixes issue #8816.
|
|
// (Also makes redundant the original check that 'require' is a function.)
|
|
ENVIRONMENT_HAS_NODE = typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string';
|
|
ENVIRONMENT_IS_NODE = ENVIRONMENT_HAS_NODE && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;
|
|
ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
|
|
|
|
|
|
|
|
// Three configurations we can be running in:
|
|
// 1) We could be the application main() thread running in the main JS UI thread. (ENVIRONMENT_IS_WORKER == false and ENVIRONMENT_IS_PTHREAD == false)
|
|
// 2) We could be the application main() thread proxied to worker. (with Emscripten -s PROXY_TO_WORKER=1) (ENVIRONMENT_IS_WORKER == true, ENVIRONMENT_IS_PTHREAD == false)
|
|
// 3) We could be an application pthread running in a worker. (ENVIRONMENT_IS_WORKER == true and ENVIRONMENT_IS_PTHREAD == true)
|
|
|
|
// ENVIRONMENT_IS_PTHREAD=true will have been preset in worker.js. Make it false in the main runtime thread.
|
|
var ENVIRONMENT_IS_PTHREAD = Module['ENVIRONMENT_IS_PTHREAD'] || false;
|
|
if (ENVIRONMENT_IS_PTHREAD) {
|
|
// Grab imports from the pthread to local scope.
|
|
buffer = Module['buffer'];
|
|
tempDoublePtr = Module['tempDoublePtr'];
|
|
DYNAMIC_BASE = Module['DYNAMIC_BASE'];
|
|
DYNAMICTOP_PTR = Module['DYNAMICTOP_PTR'];
|
|
// Note that not all runtime fields are imported above. Values for STACK_BASE, STACKTOP and STACK_MAX are not yet known at worker.js load time.
|
|
// These will be filled in at pthread startup time (the 'run' message for a pthread - pthread start establishes the stack frame)
|
|
}
|
|
|
|
|
|
|
|
|
|
// In MODULARIZE mode _scriptDir needs to be captured already at the very top of the page immediately when the page is parsed, so it is generated there
|
|
// before the page load. In non-MODULARIZE modes generate it here.
|
|
var _scriptDir = (typeof document !== 'undefined' && document.currentScript) ? document.currentScript.src : undefined;
|
|
|
|
if (ENVIRONMENT_IS_NODE) {
|
|
_scriptDir = __filename;
|
|
}
|
|
|
|
// `/` should be present at the end if `scriptDirectory` is not empty
|
|
var scriptDirectory = '';
|
|
function locateFile(path) {
|
|
if (Module['locateFile']) {
|
|
return Module['locateFile'](path, scriptDirectory);
|
|
}
|
|
return scriptDirectory + path;
|
|
}
|
|
|
|
// Hooks that are implemented differently in different runtime environments.
|
|
var read_,
|
|
readAsync,
|
|
readBinary,
|
|
setWindowTitle;
|
|
|
|
var nodeFS;
|
|
var nodePath;
|
|
|
|
if (ENVIRONMENT_IS_NODE) {
|
|
scriptDirectory = __dirname + '/';
|
|
|
|
|
|
read_ = function shell_read(filename, binary) {
|
|
if (!nodeFS) nodeFS = require('fs');
|
|
if (!nodePath) nodePath = require('path');
|
|
filename = nodePath['normalize'](filename);
|
|
return nodeFS['readFileSync'](filename, binary ? null : 'utf8');
|
|
};
|
|
|
|
readBinary = function readBinary(filename) {
|
|
var ret = read_(filename, true);
|
|
if (!ret.buffer) {
|
|
ret = new Uint8Array(ret);
|
|
}
|
|
assert(ret.buffer);
|
|
return ret;
|
|
};
|
|
|
|
|
|
|
|
|
|
if (process['argv'].length > 1) {
|
|
thisProgram = process['argv'][1].replace(/\\/g, '/');
|
|
}
|
|
|
|
arguments_ = process['argv'].slice(2);
|
|
|
|
if (typeof module !== 'undefined') {
|
|
module['exports'] = Module;
|
|
}
|
|
|
|
process['on']('uncaughtException', function(ex) {
|
|
// suppress ExitStatus exceptions from showing an error
|
|
if (!(ex instanceof ExitStatus)) {
|
|
throw ex;
|
|
}
|
|
});
|
|
|
|
process['on']('unhandledRejection', abort);
|
|
|
|
quit_ = function(status) {
|
|
process['exit'](status);
|
|
};
|
|
|
|
Module['inspect'] = function () { return '[Emscripten Module object]'; };
|
|
|
|
var nodeWorkerThreads;
|
|
try {
|
|
nodeWorkerThreads = require('worker_threads');
|
|
} catch (e) {
|
|
console.error('The "worker_threads" module is not supported in this node.js build - perhaps a newer version is needed?');
|
|
throw e;
|
|
}
|
|
Worker = nodeWorkerThreads.Worker;
|
|
|
|
} else
|
|
if (ENVIRONMENT_IS_SHELL) {
|
|
|
|
|
|
if (typeof read != 'undefined') {
|
|
read_ = function shell_read(f) {
|
|
return read(f);
|
|
};
|
|
}
|
|
|
|
readBinary = function readBinary(f) {
|
|
var data;
|
|
if (typeof readbuffer === 'function') {
|
|
return new Uint8Array(readbuffer(f));
|
|
}
|
|
data = read(f, 'binary');
|
|
assert(typeof data === 'object');
|
|
return data;
|
|
};
|
|
|
|
if (typeof scriptArgs != 'undefined') {
|
|
arguments_ = scriptArgs;
|
|
} else if (typeof arguments != 'undefined') {
|
|
arguments_ = arguments;
|
|
}
|
|
|
|
if (typeof quit === 'function') {
|
|
quit_ = function(status) {
|
|
quit(status);
|
|
};
|
|
}
|
|
|
|
if (typeof print !== 'undefined') {
|
|
// Prefer to use print/printErr where they exist, as they usually work better.
|
|
if (typeof console === 'undefined') console = {};
|
|
console.log = print;
|
|
console.warn = console.error = typeof printErr !== 'undefined' ? printErr : print;
|
|
}
|
|
} else
|
|
|
|
// Note that this includes Node.js workers when relevant (pthreads is enabled).
|
|
// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
|
|
// ENVIRONMENT_HAS_NODE.
|
|
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
|
|
if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled
|
|
scriptDirectory = self.location.href;
|
|
} else if (document.currentScript) { // web
|
|
scriptDirectory = document.currentScript.src;
|
|
}
|
|
// blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
|
|
// otherwise, slice off the final part of the url to find the script directory.
|
|
// if scriptDirectory does not contain a slash, lastIndexOf will return -1,
|
|
// and scriptDirectory will correctly be replaced with an empty string.
|
|
if (scriptDirectory.indexOf('blob:') !== 0) {
|
|
scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/')+1);
|
|
} else {
|
|
scriptDirectory = '';
|
|
}
|
|
|
|
|
|
// Differentiate the Web Worker from the Node Worker case, as reading must
|
|
// be done differently.
|
|
if (ENVIRONMENT_HAS_NODE) {
|
|
|
|
|
|
read_ = function shell_read(filename, binary) {
|
|
if (!nodeFS) nodeFS = require('fs');
|
|
if (!nodePath) nodePath = require('path');
|
|
filename = nodePath['normalize'](filename);
|
|
return nodeFS['readFileSync'](filename, binary ? null : 'utf8');
|
|
};
|
|
|
|
readBinary = function readBinary(filename) {
|
|
var ret = read_(filename, true);
|
|
if (!ret.buffer) {
|
|
ret = new Uint8Array(ret);
|
|
}
|
|
assert(ret.buffer);
|
|
return ret;
|
|
};
|
|
|
|
|
|
|
|
|
|
} else
|
|
{
|
|
|
|
|
|
read_ = function shell_read(url) {
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('GET', url, false);
|
|
xhr.send(null);
|
|
return xhr.responseText;
|
|
};
|
|
|
|
if (ENVIRONMENT_IS_WORKER) {
|
|
readBinary = function readBinary(url) {
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('GET', url, false);
|
|
xhr.responseType = 'arraybuffer';
|
|
xhr.send(null);
|
|
return new Uint8Array(xhr.response);
|
|
};
|
|
}
|
|
|
|
readAsync = function readAsync(url, onload, onerror) {
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('GET', url, true);
|
|
xhr.responseType = 'arraybuffer';
|
|
xhr.onload = function xhr_onload() {
|
|
if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
|
|
onload(xhr.response);
|
|
return;
|
|
}
|
|
onerror();
|
|
};
|
|
xhr.onerror = onerror;
|
|
xhr.send(null);
|
|
};
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
setWindowTitle = function(title) { document.title = title };
|
|
} else
|
|
{
|
|
}
|
|
|
|
if (ENVIRONMENT_HAS_NODE) {
|
|
// Polyfill the performance object, which emscripten pthreads support
|
|
// depends on for good timing.
|
|
if (typeof performance === 'undefined') {
|
|
performance = require('perf_hooks').performance;
|
|
}
|
|
}
|
|
|
|
// Set up the out() and err() hooks, which are how we can print to stdout or
|
|
// stderr, respectively.
|
|
var out = Module['print'] || console.log.bind(console);
|
|
var err = Module['printErr'] || console.warn.bind(console);
|
|
|
|
// Merge back in the overrides
|
|
for (key in moduleOverrides) {
|
|
if (moduleOverrides.hasOwnProperty(key)) {
|
|
Module[key] = moduleOverrides[key];
|
|
}
|
|
}
|
|
// Free the object hierarchy contained in the overrides, this lets the GC
|
|
// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
|
|
moduleOverrides = null;
|
|
|
|
// Emit code to handle expected values on the Module object. This applies Module.x
|
|
// to the proper local x. This has two benefits: first, we only emit it if it is
|
|
// expected to arrive, and second, by using a local everywhere else that can be
|
|
// minified.
|
|
if (Module['arguments']) arguments_ = Module['arguments'];
|
|
if (Module['thisProgram']) thisProgram = Module['thisProgram'];
|
|
if (Module['quit']) quit_ = Module['quit'];
|
|
|
|
// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
|
|
|
|
// TODO remove when SDL2 is fixed (also see above)
|
|
|
|
|
|
|
|
// Copyright 2017 The Emscripten Authors. All rights reserved.
|
|
// Emscripten is available under two separate licenses, the MIT license and the
|
|
// University of Illinois/NCSA Open Source License. Both these licenses can be
|
|
// found in the LICENSE file.
|
|
|
|
// {{PREAMBLE_ADDITIONS}}
|
|
|
|
var STACK_ALIGN = 16;
|
|
|
|
|
|
function dynamicAlloc(size) {
|
|
var ret = HEAP32[DYNAMICTOP_PTR>>2];
|
|
var end = (ret + size + 15) & -16;
|
|
if (end > _emscripten_get_heap_size()) {
|
|
abort();
|
|
}
|
|
HEAP32[DYNAMICTOP_PTR>>2] = end;
|
|
return ret;
|
|
}
|
|
|
|
function alignMemory(size, factor) {
|
|
if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default
|
|
return Math.ceil(size / factor) * factor;
|
|
}
|
|
|
|
function getNativeTypeSize(type) {
|
|
switch (type) {
|
|
case 'i1': case 'i8': return 1;
|
|
case 'i16': return 2;
|
|
case 'i32': return 4;
|
|
case 'i64': return 8;
|
|
case 'float': return 4;
|
|
case 'double': return 8;
|
|
default: {
|
|
if (type[type.length-1] === '*') {
|
|
return 4; // A pointer
|
|
} else if (type[0] === 'i') {
|
|
var bits = parseInt(type.substr(1));
|
|
assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type);
|
|
return bits / 8;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function warnOnce(text) {
|
|
if (!warnOnce.shown) warnOnce.shown = {};
|
|
if (!warnOnce.shown[text]) {
|
|
warnOnce.shown[text] = 1;
|
|
err(text);
|
|
}
|
|
}
|
|
|
|
var asm2wasmImports = { // special asm2wasm imports
|
|
"f64-rem": function(x, y) {
|
|
return x % y;
|
|
},
|
|
"debugger": function() {
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
// Wraps a JS function as a wasm function with a given signature.
|
|
function convertJsFunctionToWasm(func, sig) {
|
|
|
|
// If the type reflection proposal is available, use the new
|
|
// "WebAssembly.Function" constructor.
|
|
// Otherwise, construct a minimal wasm module importing the JS function and
|
|
// re-exporting it.
|
|
if (typeof WebAssembly.Function === "function") {
|
|
var typeNames = {
|
|
'i': 'i32',
|
|
'j': 'i64',
|
|
'f': 'f32',
|
|
'd': 'f64'
|
|
};
|
|
var type = {
|
|
parameters: [],
|
|
results: sig[0] == 'v' ? [] : [typeNames[sig[0]]]
|
|
};
|
|
for (var i = 1; i < sig.length; ++i) {
|
|
type.parameters.push(typeNames[sig[i]]);
|
|
}
|
|
return new WebAssembly.Function(type, func);
|
|
}
|
|
|
|
// The module is static, with the exception of the type section, which is
|
|
// generated based on the signature passed in.
|
|
var typeSection = [
|
|
0x01, // id: section,
|
|
0x00, // length: 0 (placeholder)
|
|
0x01, // count: 1
|
|
0x60, // form: func
|
|
];
|
|
var sigRet = sig.slice(0, 1);
|
|
var sigParam = sig.slice(1);
|
|
var typeCodes = {
|
|
'i': 0x7f, // i32
|
|
'j': 0x7e, // i64
|
|
'f': 0x7d, // f32
|
|
'd': 0x7c, // f64
|
|
};
|
|
|
|
// Parameters, length + signatures
|
|
typeSection.push(sigParam.length);
|
|
for (var i = 0; i < sigParam.length; ++i) {
|
|
typeSection.push(typeCodes[sigParam[i]]);
|
|
}
|
|
|
|
// Return values, length + signatures
|
|
// With no multi-return in MVP, either 0 (void) or 1 (anything else)
|
|
if (sigRet == 'v') {
|
|
typeSection.push(0x00);
|
|
} else {
|
|
typeSection = typeSection.concat([0x01, typeCodes[sigRet]]);
|
|
}
|
|
|
|
// Write the overall length of the type section back into the section header
|
|
// (excepting the 2 bytes for the section id and length)
|
|
typeSection[1] = typeSection.length - 2;
|
|
|
|
// Rest of the module is static
|
|
var bytes = new Uint8Array([
|
|
0x00, 0x61, 0x73, 0x6d, // magic ("\0asm")
|
|
0x01, 0x00, 0x00, 0x00, // version: 1
|
|
].concat(typeSection, [
|
|
0x02, 0x07, // import section
|
|
// (import "e" "f" (func 0 (type 0)))
|
|
0x01, 0x01, 0x65, 0x01, 0x66, 0x00, 0x00,
|
|
0x07, 0x05, // export section
|
|
// (export "f" (func 0 (type 0)))
|
|
0x01, 0x01, 0x66, 0x00, 0x00,
|
|
]));
|
|
|
|
// We can compile this wasm module synchronously because it is very small.
|
|
// This accepts an import (at "e.f"), that it reroutes to an export (at "f")
|
|
var module = new WebAssembly.Module(bytes);
|
|
var instance = new WebAssembly.Instance(module, {
|
|
'e': {
|
|
'f': func
|
|
}
|
|
});
|
|
var wrappedFunc = instance.exports['f'];
|
|
return wrappedFunc;
|
|
}
|
|
|
|
// Add a wasm function to the table.
|
|
function addFunctionWasm(func, sig) {
|
|
var table = wasmTable;
|
|
var ret = table.length;
|
|
|
|
// Grow the table
|
|
try {
|
|
table.grow(1);
|
|
} catch (err) {
|
|
if (!err instanceof RangeError) {
|
|
throw err;
|
|
}
|
|
throw 'Unable to grow wasm table. Use a higher value for RESERVED_FUNCTION_POINTERS or set ALLOW_TABLE_GROWTH.';
|
|
}
|
|
|
|
// Insert new element
|
|
try {
|
|
// Attempting to call this with JS function will cause of table.set() to fail
|
|
table.set(ret, func);
|
|
} catch (err) {
|
|
if (!err instanceof TypeError) {
|
|
throw err;
|
|
}
|
|
assert(typeof sig !== 'undefined', 'Missing signature argument to addFunction');
|
|
var wrapped = convertJsFunctionToWasm(func, sig);
|
|
table.set(ret, wrapped);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
function removeFunctionWasm(index) {
|
|
// TODO(sbc): Look into implementing this to allow re-using of table slots
|
|
}
|
|
|
|
// 'sig' parameter is required for the llvm backend but only when func is not
|
|
// already a WebAssembly function.
|
|
function addFunction(func, sig) {
|
|
|
|
return addFunctionWasm(func, sig);
|
|
}
|
|
|
|
function removeFunction(index) {
|
|
removeFunctionWasm(index);
|
|
}
|
|
|
|
var funcWrappers = {};
|
|
|
|
function getFuncWrapper(func, sig) {
|
|
if (!func) return; // on null pointer, return undefined
|
|
assert(sig);
|
|
if (!funcWrappers[sig]) {
|
|
funcWrappers[sig] = {};
|
|
}
|
|
var sigCache = funcWrappers[sig];
|
|
if (!sigCache[func]) {
|
|
// optimize away arguments usage in common cases
|
|
if (sig.length === 1) {
|
|
sigCache[func] = function dynCall_wrapper() {
|
|
return dynCall(sig, func);
|
|
};
|
|
} else if (sig.length === 2) {
|
|
sigCache[func] = function dynCall_wrapper(arg) {
|
|
return dynCall(sig, func, [arg]);
|
|
};
|
|
} else {
|
|
// general case
|
|
sigCache[func] = function dynCall_wrapper() {
|
|
return dynCall(sig, func, Array.prototype.slice.call(arguments));
|
|
};
|
|
}
|
|
}
|
|
return sigCache[func];
|
|
}
|
|
|
|
|
|
function makeBigInt(low, high, unsigned) {
|
|
return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0));
|
|
}
|
|
|
|
function dynCall(sig, ptr, args) {
|
|
if (args && args.length) {
|
|
return Module['dynCall_' + sig].apply(null, [ptr].concat(args));
|
|
} else {
|
|
return Module['dynCall_' + sig].call(null, ptr);
|
|
}
|
|
}
|
|
|
|
var tempRet0 = 0;
|
|
|
|
var setTempRet0 = function(value) {
|
|
tempRet0 = value;
|
|
};
|
|
|
|
var getTempRet0 = function() {
|
|
return tempRet0;
|
|
};
|
|
|
|
|
|
var Runtime = {
|
|
};
|
|
|
|
// The address globals begin at. Very low in memory, for code size and optimization opportunities.
|
|
// Above 0 is static memory, starting with globals.
|
|
// Then the stack.
|
|
// Then 'dynamic' memory for sbrk.
|
|
var GLOBAL_BASE = 1024;
|
|
|
|
|
|
// The wasm backend path does not have a way to set the stack max, so we can
|
|
// just implement this function in a trivial way
|
|
function establishStackSpace(base, max) {
|
|
stackRestore(max);
|
|
}
|
|
|
|
// JS library code refers to Atomics in the manner used from asm.js, provide
|
|
// the same API here.
|
|
var Atomics_load = Atomics.load;
|
|
var Atomics_store = Atomics.store;
|
|
var Atomics_compareExchange = Atomics.compareExchange;
|
|
|
|
|
|
// === 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
|
|
|
|
|
|
var wasmBinary;if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];
|
|
var noExitRuntime;if (Module['noExitRuntime']) noExitRuntime = Module['noExitRuntime'];
|
|
|
|
|
|
if (typeof WebAssembly !== 'object') {
|
|
err('no native wasm support detected');
|
|
}
|
|
|
|
|
|
// In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking.
|
|
// In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties)
|
|
|
|
/** @type {function(number, number, string, boolean=)} */
|
|
function setValue(ptr, value, type, noSafe) {
|
|
type = type || 'i8';
|
|
if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
|
|
switch(type) {
|
|
case 'i1': HEAP8[((ptr)>>0)]=value; break;
|
|
case 'i8': HEAP8[((ptr)>>0)]=value; break;
|
|
case 'i16': HEAP16[((ptr)>>1)]=value; break;
|
|
case 'i32': HEAP32[((ptr)>>2)]=value; break;
|
|
case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math_min((+(Math_floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
|
|
case 'float': HEAPF32[((ptr)>>2)]=value; break;
|
|
case 'double': HEAPF64[((ptr)>>3)]=value; break;
|
|
default: abort('invalid type for setValue: ' + type);
|
|
}
|
|
}
|
|
|
|
/** @type {function(number, string, boolean=)} */
|
|
function getValue(ptr, type, noSafe) {
|
|
type = type || 'i8';
|
|
if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
|
|
switch(type) {
|
|
case 'i1': return HEAP8[((ptr)>>0)];
|
|
case 'i8': return HEAP8[((ptr)>>0)];
|
|
case 'i16': return HEAP16[((ptr)>>1)];
|
|
case 'i32': return HEAP32[((ptr)>>2)];
|
|
case 'i64': return HEAP32[((ptr)>>2)];
|
|
case 'float': return HEAPF32[((ptr)>>2)];
|
|
case 'double': return HEAPF64[((ptr)>>3)];
|
|
default: abort('invalid type for getValue: ' + type);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Wasm globals
|
|
|
|
var wasmMemory;
|
|
|
|
// In fastcomp asm.js, we don't need a wasm Table at all.
|
|
// In the wasm backend, we polyfill the WebAssembly object,
|
|
// so this creates a (non-native-wasm) table for us.
|
|
var wasmTable = new WebAssembly.Table({
|
|
'initial': 58617,
|
|
'maximum': 58617 + 0,
|
|
'element': 'anyfunc'
|
|
});
|
|
|
|
// For sending to workers.
|
|
var wasmModule;
|
|
// Only workers actually use these field, but we refer to them from
|
|
// library_pthread (which exists on all threads) so this definition is useful
|
|
// to avoid accessing the global scope.
|
|
var threadInfoStruct = 0;
|
|
var selfThreadId = 0;
|
|
var __performance_now_clock_drift = 0;
|
|
var tempDoublePtr = 0;
|
|
|
|
//========================================
|
|
// Runtime essentials
|
|
//========================================
|
|
|
|
// whether we are quitting the application. no code should run after this.
|
|
// set in exit() and abort()
|
|
var ABORT = false;
|
|
|
|
// set by exit() and abort(). Passed to 'onExit' handler.
|
|
// NOTE: This is also used as the process return code code in shell environments
|
|
// but only when noExitRuntime is false.
|
|
var EXITSTATUS = 0;
|
|
|
|
/** @type {function(*, string=)} */
|
|
function assert(condition, text) {
|
|
if (!condition) {
|
|
abort('Assertion failed: ' + text);
|
|
}
|
|
}
|
|
|
|
// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
|
|
function getCFunc(ident) {
|
|
var func = Module['_' + ident]; // closure exported function
|
|
assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported');
|
|
return func;
|
|
}
|
|
|
|
// C calling interface.
|
|
function ccall(ident, returnType, argTypes, args, opts) {
|
|
// For fast lookup of conversion functions
|
|
var toC = {
|
|
'string': function(str) {
|
|
var ret = 0;
|
|
if (str !== null && str !== undefined && str !== 0) { // null string
|
|
// at most 4 bytes per UTF-8 code point, +1 for the trailing '\0'
|
|
var len = (str.length << 2) + 1;
|
|
ret = stackAlloc(len);
|
|
stringToUTF8(str, ret, len);
|
|
}
|
|
return ret;
|
|
},
|
|
'array': function(arr) {
|
|
var ret = stackAlloc(arr.length);
|
|
writeArrayToMemory(arr, ret);
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
function convertReturnValue(ret) {
|
|
if (returnType === 'string') return UTF8ToString(ret);
|
|
if (returnType === 'boolean') return Boolean(ret);
|
|
return ret;
|
|
}
|
|
|
|
var func = getCFunc(ident);
|
|
var cArgs = [];
|
|
var stack = 0;
|
|
if (args) {
|
|
for (var i = 0; i < args.length; i++) {
|
|
var converter = toC[argTypes[i]];
|
|
if (converter) {
|
|
if (stack === 0) stack = stackSave();
|
|
cArgs[i] = converter(args[i]);
|
|
} else {
|
|
cArgs[i] = args[i];
|
|
}
|
|
}
|
|
}
|
|
var ret = func.apply(null, cArgs);
|
|
|
|
ret = convertReturnValue(ret);
|
|
if (stack !== 0) stackRestore(stack);
|
|
return ret;
|
|
}
|
|
|
|
function cwrap(ident, returnType, argTypes, opts) {
|
|
argTypes = argTypes || [];
|
|
// When the function takes numbers and returns a number, we can just return
|
|
// the original function
|
|
var numericArgs = argTypes.every(function(type){ return type === 'number'});
|
|
var numericRet = returnType !== 'string';
|
|
if (numericRet && numericArgs && !opts) {
|
|
return getCFunc(ident);
|
|
}
|
|
return function() {
|
|
return ccall(ident, returnType, argTypes, arguments, opts);
|
|
}
|
|
}
|
|
|
|
var ALLOC_NORMAL = 0; // Tries to use _malloc()
|
|
var ALLOC_STACK = 1; // Lives for the duration of the current function call
|
|
var ALLOC_DYNAMIC = 2; // Cannot be freed except through sbrk
|
|
var ALLOC_NONE = 3; // Do not allocate
|
|
|
|
// allocate(): This is for internal use. You can use it yourself as well, but the interface
|
|
// is a little tricky (see docs right below). The reason is that it is optimized
|
|
// for multiple syntaxes to save space in generated code. So you should
|
|
// normally not use allocate(), and instead allocate memory using _malloc(),
|
|
// initialize it with setValue(), and so forth.
|
|
// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
|
|
// in *bytes* (note that this is sometimes confusing: the next parameter does not
|
|
// affect this!)
|
|
// @types: Either an array of types, one for each byte (or 0 if no type at that position),
|
|
// or a single type which is used for the entire block. This only matters if there
|
|
// is initial data - if @slab is a number, then this does not matter at all and is
|
|
// ignored.
|
|
// @allocator: How to allocate memory, see ALLOC_*
|
|
/** @type {function((TypedArray|Array<number>|number), string, number, number=)} */
|
|
function allocate(slab, types, allocator, ptr) {
|
|
var zeroinit, size;
|
|
if (typeof slab === 'number') {
|
|
zeroinit = true;
|
|
size = slab;
|
|
} else {
|
|
zeroinit = false;
|
|
size = slab.length;
|
|
}
|
|
|
|
var singleType = typeof types === 'string' ? types : null;
|
|
|
|
var ret;
|
|
if (allocator == ALLOC_NONE) {
|
|
ret = ptr;
|
|
} else {
|
|
ret = [_malloc,
|
|
stackAlloc,
|
|
dynamicAlloc][allocator](Math.max(size, singleType ? 1 : types.length));
|
|
}
|
|
|
|
if (zeroinit) {
|
|
var stop;
|
|
ptr = ret;
|
|
assert((ret & 3) == 0);
|
|
stop = ret + (size & ~3);
|
|
for (; ptr < stop; ptr += 4) {
|
|
HEAP32[((ptr)>>2)]=0;
|
|
}
|
|
stop = ret + size;
|
|
while (ptr < stop) {
|
|
HEAP8[((ptr++)>>0)]=0;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
if (singleType === 'i8') {
|
|
if (slab.subarray || slab.slice) {
|
|
HEAPU8.set(/** @type {!Uint8Array} */ (slab), ret);
|
|
} else {
|
|
HEAPU8.set(new Uint8Array(slab), ret);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
var i = 0, type, typeSize, previousType;
|
|
while (i < size) {
|
|
var curr = slab[i];
|
|
|
|
type = singleType || types[i];
|
|
if (type === 0) {
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
|
|
|
|
setValue(ret+i, curr, type);
|
|
|
|
// no need to look up size unless type changes, so cache it
|
|
if (previousType !== type) {
|
|
typeSize = getNativeTypeSize(type);
|
|
previousType = type;
|
|
}
|
|
i += typeSize;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
// Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready
|
|
function getMemory(size) {
|
|
if (!runtimeInitialized) return dynamicAlloc(size);
|
|
return _malloc(size);
|
|
}
|
|
|
|
|
|
|
|
|
|
/** @type {function(number, number=)} */
|
|
function Pointer_stringify(ptr, length) {
|
|
abort("this function has been removed - you should use UTF8ToString(ptr, maxBytesToRead) instead!");
|
|
}
|
|
|
|
// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns
|
|
// a copy of that string as a Javascript String object.
|
|
|
|
function AsciiToString(ptr) {
|
|
var str = '';
|
|
while (1) {
|
|
var ch = HEAPU8[((ptr++)>>0)];
|
|
if (!ch) return str;
|
|
str += String.fromCharCode(ch);
|
|
}
|
|
}
|
|
|
|
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
|
|
// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP.
|
|
|
|
function stringToAscii(str, outPtr) {
|
|
return writeAsciiToMemory(str, outPtr, false);
|
|
}
|
|
|
|
|
|
// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns
|
|
// a copy of that string as a Javascript String object.
|
|
|
|
|
|
/**
|
|
* @param {number} idx
|
|
* @param {number=} maxBytesToRead
|
|
* @return {string}
|
|
*/
|
|
function UTF8ArrayToString(u8Array, idx, maxBytesToRead) {
|
|
var endIdx = idx + maxBytesToRead;
|
|
|
|
var str = '';
|
|
while (!(idx >= endIdx)) {
|
|
// For UTF8 byte structure, see:
|
|
// http://en.wikipedia.org/wiki/UTF-8#Description
|
|
// https://www.ietf.org/rfc/rfc2279.txt
|
|
// https://tools.ietf.org/html/rfc3629
|
|
var u0 = u8Array[idx++];
|
|
// If not building with TextDecoder enabled, we don't know the string length, so scan for \0 byte.
|
|
// If building with TextDecoder, we know exactly at what byte index the string ends, so checking for nulls here would be redundant.
|
|
if (!u0) return str;
|
|
if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }
|
|
var u1 = u8Array[idx++] & 63;
|
|
if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }
|
|
var u2 = u8Array[idx++] & 63;
|
|
if ((u0 & 0xF0) == 0xE0) {
|
|
u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
|
|
} else {
|
|
u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (u8Array[idx++] & 63);
|
|
}
|
|
|
|
if (u0 < 0x10000) {
|
|
str += String.fromCharCode(u0);
|
|
} else {
|
|
var ch = u0 - 0x10000;
|
|
str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
|
|
// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a
|
|
// copy of that string as a Javascript String object.
|
|
// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit
|
|
// this parameter to scan the string until the first \0 byte. If maxBytesToRead is
|
|
// passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the
|
|
// middle, then the string will cut short at that byte index (i.e. maxBytesToRead will
|
|
// not produce a string of exact length [ptr, ptr+maxBytesToRead[)
|
|
// N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may
|
|
// throw JS JIT optimizations off, so it is worth to consider consistently using one
|
|
// style or the other.
|
|
/**
|
|
* @param {number} ptr
|
|
* @param {number=} maxBytesToRead
|
|
* @return {string}
|
|
*/
|
|
function UTF8ToString(ptr, maxBytesToRead) {
|
|
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
|
|
}
|
|
|
|
// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx',
|
|
// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP.
|
|
// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
|
|
// Parameters:
|
|
// str: the Javascript string to copy.
|
|
// outU8Array: the array to copy to. Each index in this array is assumed to be one 8-byte element.
|
|
// outIdx: The starting offset in the array to begin the copying.
|
|
// maxBytesToWrite: The maximum number of bytes this function can write to the array.
|
|
// This count should include the null terminator,
|
|
// i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else.
|
|
// maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator.
|
|
// Returns the number of bytes written, EXCLUDING the null terminator.
|
|
|
|
function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
|
|
if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes.
|
|
return 0;
|
|
|
|
var startIdx = outIdx;
|
|
var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
|
|
for (var i = 0; i < str.length; ++i) {
|
|
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
|
|
// See http://unicode.org/faq/utf_bom.html#utf16-3
|
|
// For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629
|
|
var u = str.charCodeAt(i); // possibly a lead surrogate
|
|
if (u >= 0xD800 && u <= 0xDFFF) {
|
|
var u1 = str.charCodeAt(++i);
|
|
u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);
|
|
}
|
|
if (u <= 0x7F) {
|
|
if (outIdx >= endIdx) break;
|
|
outU8Array[outIdx++] = u;
|
|
} else if (u <= 0x7FF) {
|
|
if (outIdx + 1 >= endIdx) break;
|
|
outU8Array[outIdx++] = 0xC0 | (u >> 6);
|
|
outU8Array[outIdx++] = 0x80 | (u & 63);
|
|
} else if (u <= 0xFFFF) {
|
|
if (outIdx + 2 >= endIdx) break;
|
|
outU8Array[outIdx++] = 0xE0 | (u >> 12);
|
|
outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
|
|
outU8Array[outIdx++] = 0x80 | (u & 63);
|
|
} else {
|
|
if (outIdx + 3 >= endIdx) break;
|
|
outU8Array[outIdx++] = 0xF0 | (u >> 18);
|
|
outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63);
|
|
outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
|
|
outU8Array[outIdx++] = 0x80 | (u & 63);
|
|
}
|
|
}
|
|
// Null-terminate the pointer to the buffer.
|
|
outU8Array[outIdx] = 0;
|
|
return outIdx - startIdx;
|
|
}
|
|
|
|
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
|
|
// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP.
|
|
// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
|
|
// Returns the number of bytes written, EXCLUDING the null terminator.
|
|
|
|
function stringToUTF8(str, outPtr, maxBytesToWrite) {
|
|
return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite);
|
|
}
|
|
|
|
// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte.
|
|
function lengthBytesUTF8(str) {
|
|
var len = 0;
|
|
for (var i = 0; i < str.length; ++i) {
|
|
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
|
|
// See http://unicode.org/faq/utf_bom.html#utf16-3
|
|
var u = str.charCodeAt(i); // possibly a lead surrogate
|
|
if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF);
|
|
if (u <= 0x7F) ++len;
|
|
else if (u <= 0x7FF) len += 2;
|
|
else if (u <= 0xFFFF) len += 3;
|
|
else len += 4;
|
|
}
|
|
return len;
|
|
}
|
|
|
|
|
|
// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
|
|
// a copy of that string as a Javascript String object.
|
|
|
|
function UTF16ToString(ptr) {
|
|
var i = 0;
|
|
|
|
var str = '';
|
|
while (1) {
|
|
var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
|
|
if (codeUnit == 0) return str;
|
|
++i;
|
|
// fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
|
|
str += String.fromCharCode(codeUnit);
|
|
}
|
|
}
|
|
|
|
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
|
|
// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP.
|
|
// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write.
|
|
// Parameters:
|
|
// str: the Javascript string to copy.
|
|
// outPtr: Byte address in Emscripten HEAP where to write the string to.
|
|
// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
|
|
// terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else.
|
|
// maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator.
|
|
// Returns the number of bytes written, EXCLUDING the null terminator.
|
|
|
|
function stringToUTF16(str, outPtr, maxBytesToWrite) {
|
|
// Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
|
|
if (maxBytesToWrite === undefined) {
|
|
maxBytesToWrite = 0x7FFFFFFF;
|
|
}
|
|
if (maxBytesToWrite < 2) return 0;
|
|
maxBytesToWrite -= 2; // Null terminator.
|
|
var startPtr = outPtr;
|
|
var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length;
|
|
for (var i = 0; i < numCharsToWrite; ++i) {
|
|
// charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
|
|
var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
|
|
HEAP16[((outPtr)>>1)]=codeUnit;
|
|
outPtr += 2;
|
|
}
|
|
// Null-terminate the pointer to the HEAP.
|
|
HEAP16[((outPtr)>>1)]=0;
|
|
return outPtr - startPtr;
|
|
}
|
|
|
|
// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.
|
|
|
|
function lengthBytesUTF16(str) {
|
|
return str.length*2;
|
|
}
|
|
|
|
function UTF32ToString(ptr) {
|
|
var i = 0;
|
|
|
|
var str = '';
|
|
while (1) {
|
|
var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
|
|
if (utf32 == 0)
|
|
return str;
|
|
++i;
|
|
// Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
|
|
// See http://unicode.org/faq/utf_bom.html#utf16-3
|
|
if (utf32 >= 0x10000) {
|
|
var ch = utf32 - 0x10000;
|
|
str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
|
|
} else {
|
|
str += String.fromCharCode(utf32);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
|
|
// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP.
|
|
// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write.
|
|
// Parameters:
|
|
// str: the Javascript string to copy.
|
|
// outPtr: Byte address in Emscripten HEAP where to write the string to.
|
|
// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
|
|
// terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else.
|
|
// maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator.
|
|
// Returns the number of bytes written, EXCLUDING the null terminator.
|
|
|
|
function stringToUTF32(str, outPtr, maxBytesToWrite) {
|
|
// Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
|
|
if (maxBytesToWrite === undefined) {
|
|
maxBytesToWrite = 0x7FFFFFFF;
|
|
}
|
|
if (maxBytesToWrite < 4) return 0;
|
|
var startPtr = outPtr;
|
|
var endPtr = startPtr + maxBytesToWrite - 4;
|
|
for (var i = 0; i < str.length; ++i) {
|
|
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
|
|
// See http://unicode.org/faq/utf_bom.html#utf16-3
|
|
var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
|
|
if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
|
|
var trailSurrogate = str.charCodeAt(++i);
|
|
codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
|
|
}
|
|
HEAP32[((outPtr)>>2)]=codeUnit;
|
|
outPtr += 4;
|
|
if (outPtr + 4 > endPtr) break;
|
|
}
|
|
// Null-terminate the pointer to the HEAP.
|
|
HEAP32[((outPtr)>>2)]=0;
|
|
return outPtr - startPtr;
|
|
}
|
|
|
|
// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.
|
|
|
|
function lengthBytesUTF32(str) {
|
|
var len = 0;
|
|
for (var i = 0; i < str.length; ++i) {
|
|
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
|
|
// See http://unicode.org/faq/utf_bom.html#utf16-3
|
|
var codeUnit = str.charCodeAt(i);
|
|
if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate.
|
|
len += 4;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
// Allocate heap space for a JS string, and write it there.
|
|
// It is the responsibility of the caller to free() that memory.
|
|
function allocateUTF8(str) {
|
|
var size = lengthBytesUTF8(str) + 1;
|
|
var ret = _malloc(size);
|
|
if (ret) stringToUTF8Array(str, HEAP8, ret, size);
|
|
return ret;
|
|
}
|
|
|
|
// Allocate stack space for a JS string, and write it there.
|
|
function allocateUTF8OnStack(str) {
|
|
var size = lengthBytesUTF8(str) + 1;
|
|
var ret = stackAlloc(size);
|
|
stringToUTF8Array(str, HEAP8, ret, size);
|
|
return ret;
|
|
}
|
|
|
|
// Deprecated: This function should not be called because it is unsafe and does not provide
|
|
// a maximum length limit of how many bytes it is allowed to write. Prefer calling the
|
|
// function stringToUTF8Array() instead, which takes in a maximum length that can be used
|
|
// to be secure from out of bounds writes.
|
|
/** @deprecated */
|
|
function writeStringToMemory(string, buffer, dontAddNull) {
|
|
warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!');
|
|
|
|
var /** @type {number} */ lastChar, /** @type {number} */ end;
|
|
if (dontAddNull) {
|
|
// stringToUTF8Array always appends null. If we don't want to do that, remember the
|
|
// character that existed at the location where the null will be placed, and restore
|
|
// that after the write (below).
|
|
end = buffer + lengthBytesUTF8(string);
|
|
lastChar = HEAP8[end];
|
|
}
|
|
stringToUTF8(string, buffer, Infinity);
|
|
if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character.
|
|
}
|
|
|
|
function writeArrayToMemory(array, buffer) {
|
|
HEAP8.set(array, buffer);
|
|
}
|
|
|
|
function writeAsciiToMemory(str, buffer, dontAddNull) {
|
|
for (var i = 0; i < str.length; ++i) {
|
|
HEAP8[((buffer++)>>0)]=str.charCodeAt(i);
|
|
}
|
|
// Null-terminate the pointer to the HEAP.
|
|
if (!dontAddNull) HEAP8[((buffer)>>0)]=0;
|
|
}
|
|
|
|
|
|
|
|
|
|
// Memory management
|
|
|
|
var PAGE_SIZE = 16384;
|
|
var WASM_PAGE_SIZE = 65536;
|
|
var ASMJS_PAGE_SIZE = 16777216;
|
|
|
|
function alignUp(x, multiple) {
|
|
if (x % multiple > 0) {
|
|
x += multiple - (x % multiple);
|
|
}
|
|
return x;
|
|
}
|
|
|
|
var HEAP,
|
|
/** @type {ArrayBuffer} */
|
|
buffer,
|
|
/** @type {Int8Array} */
|
|
HEAP8,
|
|
/** @type {Uint8Array} */
|
|
HEAPU8,
|
|
/** @type {Int16Array} */
|
|
HEAP16,
|
|
/** @type {Uint16Array} */
|
|
HEAPU16,
|
|
/** @type {Int32Array} */
|
|
HEAP32,
|
|
/** @type {Uint32Array} */
|
|
HEAPU32,
|
|
/** @type {Float32Array} */
|
|
HEAPF32,
|
|
/** @type {Float64Array} */
|
|
HEAPF64;
|
|
|
|
function updateGlobalBufferAndViews(buf) {
|
|
buffer = buf;
|
|
Module['HEAP8'] = HEAP8 = new Int8Array(buf);
|
|
Module['HEAP16'] = HEAP16 = new Int16Array(buf);
|
|
Module['HEAP32'] = HEAP32 = new Int32Array(buf);
|
|
Module['HEAPU8'] = HEAPU8 = new Uint8Array(buf);
|
|
Module['HEAPU16'] = HEAPU16 = new Uint16Array(buf);
|
|
Module['HEAPU32'] = HEAPU32 = new Uint32Array(buf);
|
|
Module['HEAPF32'] = HEAPF32 = new Float32Array(buf);
|
|
Module['HEAPF64'] = HEAPF64 = new Float64Array(buf);
|
|
}
|
|
|
|
var STATIC_BASE = 1024,
|
|
STACK_BASE = 15447248,
|
|
STACKTOP = STACK_BASE,
|
|
STACK_MAX = 10204368,
|
|
DYNAMIC_BASE = 15447248,
|
|
DYNAMICTOP_PTR = 10203408;
|
|
|
|
|
|
if (ENVIRONMENT_IS_PTHREAD) {
|
|
|
|
// At the 'load' stage of Worker startup, we are just loading this script
|
|
// but not ready to run yet. At 'run' we receive proper values for the stack
|
|
// etc. and can launch a pthread. Set some fake values there meanwhile to
|
|
// catch bugs, then set the real values in applyStackValues later.
|
|
|
|
Module['applyStackValues'] = function(stackBase, stackTop, stackMax) {
|
|
STACK_BASE = stackBase;
|
|
STACKTOP = stackTop;
|
|
STACK_MAX = stackMax;
|
|
};
|
|
|
|
// TODO DYNAMIC_BASE = Module['DYNAMIC_BASE'];
|
|
// TODO DYNAMICTOP_PTR = Module['DYNAMICTOP_PTR'];
|
|
// TODO tempDoublePtr = Module['tempDoublePtr'];
|
|
}
|
|
|
|
|
|
var TOTAL_STACK = 5242880;
|
|
|
|
var INITIAL_TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 149880832;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// In standalone mode, the wasm creates the memory, and the user can't provide it.
|
|
// In non-standalone/normal mode, we create the memory here.
|
|
|
|
// Create the main memory. (Note: this isn't used in STANDALONE_WASM mode since the wasm
|
|
// memory is created in the wasm, not in JS.)
|
|
if (ENVIRONMENT_IS_PTHREAD) {
|
|
wasmMemory = Module['wasmMemory'];
|
|
buffer = Module['buffer'];
|
|
} else {
|
|
|
|
if (Module['wasmMemory']) {
|
|
wasmMemory = Module['wasmMemory'];
|
|
} else
|
|
{
|
|
wasmMemory = new WebAssembly.Memory({
|
|
'initial': INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE
|
|
,
|
|
'maximum': INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE
|
|
,
|
|
'shared': true
|
|
});
|
|
if (!(wasmMemory.buffer instanceof SharedArrayBuffer)) {
|
|
err('requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag');
|
|
if (ENVIRONMENT_HAS_NODE) {
|
|
console.log('(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and also use a recent version)');
|
|
}
|
|
throw Error('bad memory');
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if (wasmMemory) {
|
|
buffer = wasmMemory.buffer;
|
|
}
|
|
|
|
// If the user provides an incorrect length, just use that length instead rather than providing the user to
|
|
// specifically provide the memory length with Module['TOTAL_MEMORY'].
|
|
INITIAL_TOTAL_MEMORY = buffer.byteLength;
|
|
updateGlobalBufferAndViews(buffer);
|
|
|
|
if (!ENVIRONMENT_IS_PTHREAD) { // Pthreads have already initialized these variables in src/worker.js, where they were passed to the thread worker at startup time
|
|
HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function callRuntimeCallbacks(callbacks) {
|
|
while(callbacks.length > 0) {
|
|
var callback = callbacks.shift();
|
|
if (typeof callback == 'function') {
|
|
callback();
|
|
continue;
|
|
}
|
|
var func = callback.func;
|
|
if (typeof func === 'number') {
|
|
if (callback.arg === undefined) {
|
|
Module['dynCall_v'](func);
|
|
} else {
|
|
Module['dynCall_vi'](func, callback.arg);
|
|
}
|
|
} else {
|
|
func(callback.arg === undefined ? null : callback.arg);
|
|
}
|
|
}
|
|
}
|
|
|
|
var __ATPRERUN__ = []; // functions called before the runtime is initialized
|
|
var __ATINIT__ = []; // functions called during startup
|
|
var __ATMAIN__ = []; // functions called when main() is to be run
|
|
var __ATEXIT__ = []; // functions called during shutdown
|
|
var __ATPOSTRUN__ = []; // functions called after the main() is called
|
|
|
|
var runtimeInitialized = false;
|
|
var runtimeExited = false;
|
|
|
|
if (ENVIRONMENT_IS_PTHREAD) runtimeInitialized = true; // The runtime is hosted in the main thread, and bits shared to pthreads via SharedArrayBuffer. No need to init again in pthread.
|
|
|
|
function preRun() {
|
|
if (ENVIRONMENT_IS_PTHREAD) return; // PThreads reuse the runtime from the main thread.
|
|
|
|
if (Module['preRun']) {
|
|
if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
|
|
while (Module['preRun'].length) {
|
|
addOnPreRun(Module['preRun'].shift());
|
|
}
|
|
}
|
|
|
|
callRuntimeCallbacks(__ATPRERUN__);
|
|
}
|
|
|
|
function initRuntime() {
|
|
runtimeInitialized = true;
|
|
if (!Module["noFSInit"] && !FS.init.initialized) FS.init();
|
|
TTY.init();
|
|
callRuntimeCallbacks(__ATINIT__);
|
|
}
|
|
|
|
function preMain() {
|
|
if (ENVIRONMENT_IS_PTHREAD) return; // PThreads reuse the runtime from the main thread.
|
|
FS.ignorePermissions = false;
|
|
callRuntimeCallbacks(__ATMAIN__);
|
|
}
|
|
|
|
function exitRuntime() {
|
|
if (ENVIRONMENT_IS_PTHREAD) return; // PThreads reuse the runtime from the main thread.
|
|
runtimeExited = true;
|
|
}
|
|
|
|
function postRun() {
|
|
if (ENVIRONMENT_IS_PTHREAD) return; // PThreads reuse the runtime from the main thread.
|
|
|
|
if (Module['postRun']) {
|
|
if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
|
|
while (Module['postRun'].length) {
|
|
addOnPostRun(Module['postRun'].shift());
|
|
}
|
|
}
|
|
|
|
callRuntimeCallbacks(__ATPOSTRUN__);
|
|
}
|
|
|
|
function addOnPreRun(cb) {
|
|
__ATPRERUN__.unshift(cb);
|
|
}
|
|
|
|
function addOnInit(cb) {
|
|
__ATINIT__.unshift(cb);
|
|
}
|
|
|
|
function addOnPreMain(cb) {
|
|
__ATMAIN__.unshift(cb);
|
|
}
|
|
|
|
function addOnExit(cb) {
|
|
}
|
|
|
|
function addOnPostRun(cb) {
|
|
__ATPOSTRUN__.unshift(cb);
|
|
}
|
|
|
|
function unSign(value, bits, ignore) {
|
|
if (value >= 0) {
|
|
return value;
|
|
}
|
|
return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
|
|
: Math.pow(2, bits) + value;
|
|
}
|
|
function reSign(value, bits, ignore) {
|
|
if (value <= 0) {
|
|
return value;
|
|
}
|
|
var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
|
|
: Math.pow(2, bits-1);
|
|
if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
|
|
// but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
|
|
// TODO: In i64 mode 1, resign the two parts separately and safely
|
|
value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
|
|
}
|
|
return value;
|
|
}
|
|
|
|
|
|
|
|
var Math_abs = Math.abs;
|
|
var Math_cos = Math.cos;
|
|
var Math_sin = Math.sin;
|
|
var Math_tan = Math.tan;
|
|
var Math_acos = Math.acos;
|
|
var Math_asin = Math.asin;
|
|
var Math_atan = Math.atan;
|
|
var Math_atan2 = Math.atan2;
|
|
var Math_exp = Math.exp;
|
|
var Math_log = Math.log;
|
|
var Math_sqrt = Math.sqrt;
|
|
var Math_ceil = Math.ceil;
|
|
var Math_floor = Math.floor;
|
|
var Math_pow = Math.pow;
|
|
var Math_imul = Math.imul;
|
|
var Math_fround = Math.fround;
|
|
var Math_round = Math.round;
|
|
var Math_min = Math.min;
|
|
var Math_max = Math.max;
|
|
var Math_clz32 = Math.clz32;
|
|
var Math_trunc = Math.trunc;
|
|
|
|
|
|
|
|
// A counter of dependencies for calling run(). If we need to
|
|
// do asynchronous work before running, increment this and
|
|
// decrement it. Incrementing must happen in a place like
|
|
// Module.preRun (used by emcc to add file preloading).
|
|
// Note that you can add dependencies in preRun, even though
|
|
// it happens right before run - run will be postponed until
|
|
// the dependencies are met.
|
|
var runDependencies = 0;
|
|
var runDependencyWatcher = null;
|
|
var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
|
|
|
|
function getUniqueRunDependency(id) {
|
|
return id;
|
|
}
|
|
|
|
function addRunDependency(id) {
|
|
// We should never get here in pthreads (could no-op this out if called in pthreads, but that might indicate a bug in caller side,
|
|
// so good to be very explicit)
|
|
assert(!ENVIRONMENT_IS_PTHREAD, "addRunDependency cannot be used in a pthread worker");
|
|
runDependencies++;
|
|
|
|
if (Module['monitorRunDependencies']) {
|
|
Module['monitorRunDependencies'](runDependencies);
|
|
}
|
|
|
|
}
|
|
|
|
function removeRunDependency(id) {
|
|
runDependencies--;
|
|
|
|
if (Module['monitorRunDependencies']) {
|
|
Module['monitorRunDependencies'](runDependencies);
|
|
}
|
|
|
|
if (runDependencies == 0) {
|
|
if (runDependencyWatcher !== null) {
|
|
clearInterval(runDependencyWatcher);
|
|
runDependencyWatcher = null;
|
|
}
|
|
if (dependenciesFulfilled) {
|
|
var callback = dependenciesFulfilled;
|
|
dependenciesFulfilled = null;
|
|
callback(); // can add another dependenciesFulfilled
|
|
}
|
|
}
|
|
}
|
|
|
|
Module["preloadedImages"] = {}; // maps url to image data
|
|
Module["preloadedAudios"] = {}; // maps url to audio data
|
|
|
|
|
|
function abort(what) {
|
|
if (Module['onAbort']) {
|
|
Module['onAbort'](what);
|
|
}
|
|
|
|
if (ENVIRONMENT_IS_PTHREAD) console.error('Pthread aborting at ' + new Error().stack);
|
|
what += '';
|
|
out(what);
|
|
err(what);
|
|
|
|
ABORT = true;
|
|
EXITSTATUS = 1;
|
|
|
|
what = 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.';
|
|
|
|
// Throw a wasm runtime error, because a JS error might be seen as a foreign
|
|
// exception, which means we'd run destructors on it. We need the error to
|
|
// simply make the program stop.
|
|
throw new WebAssembly.RuntimeError(what);
|
|
}
|
|
|
|
|
|
var memoryInitializer = null;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Copyright 2017 The Emscripten Authors. All rights reserved.
|
|
// Emscripten is available under two separate licenses, the MIT license and the
|
|
// University of Illinois/NCSA Open Source License. Both these licenses can be
|
|
// found in the LICENSE file.
|
|
|
|
// Prefix of data URIs emitted by SINGLE_FILE and related options.
|
|
var dataURIPrefix = 'data:application/octet-stream;base64,';
|
|
|
|
// Indicates whether filename is a base64 data URI.
|
|
function isDataURI(filename) {
|
|
return String.prototype.startsWith ?
|
|
filename.startsWith(dataURIPrefix) :
|
|
filename.indexOf(dataURIPrefix) === 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
var wasmBinaryFile = 'x2t.wasm';
|
|
if (!isDataURI(wasmBinaryFile)) {
|
|
wasmBinaryFile = locateFile(wasmBinaryFile);
|
|
}
|
|
|
|
function getBinary() {
|
|
try {
|
|
if (wasmBinary) {
|
|
return new Uint8Array(wasmBinary);
|
|
}
|
|
|
|
if (readBinary) {
|
|
return readBinary(wasmBinaryFile);
|
|
} else {
|
|
throw "both async and sync fetching of the wasm failed";
|
|
}
|
|
}
|
|
catch (err) {
|
|
abort(err);
|
|
}
|
|
}
|
|
|
|
function getBinaryPromise() {
|
|
// if we don't have the binary yet, and have the Fetch api, use that
|
|
// in some environments, like Electron's render process, Fetch api may be present, but have a different context than expected, let's only use it on the Web
|
|
if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === 'function') {
|
|
return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) {
|
|
if (!response['ok']) {
|
|
throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
|
|
}
|
|
return response['arrayBuffer']();
|
|
}).catch(function () {
|
|
return getBinary();
|
|
});
|
|
}
|
|
// Otherwise, getBinary should be able to get it synchronously
|
|
return new Promise(function(resolve, reject) {
|
|
resolve(getBinary());
|
|
});
|
|
}
|
|
|
|
|
|
|
|
// Create the wasm instance.
|
|
// Receives the wasm imports, returns the exports.
|
|
function createWasm() {
|
|
// prepare imports
|
|
var info = {
|
|
'env': asmLibraryArg,
|
|
'wasi_unstable': asmLibraryArg
|
|
};
|
|
// Load the wasm module and create an instance of using native support in the JS engine.
|
|
// handle a generated wasm instance, receiving its exports and
|
|
// performing other necessary setup
|
|
function receiveInstance(instance, module) {
|
|
var exports = instance.exports;
|
|
Module['asm'] = exports;
|
|
// Keep a reference to the compiled module so we can post it to the workers.
|
|
wasmModule = module;
|
|
// Instantiation is synchronous in pthreads and we assert on run dependencies.
|
|
if (!ENVIRONMENT_IS_PTHREAD) removeRunDependency('wasm-instantiate');
|
|
}
|
|
// we can't run yet (except in a pthread, where we have a custom sync instantiator)
|
|
if (!ENVIRONMENT_IS_PTHREAD) { addRunDependency('wasm-instantiate'); }
|
|
|
|
|
|
function receiveInstantiatedSource(output) {
|
|
// 'output' is a WebAssemblyInstantiatedSource object which has both the module and instance.
|
|
// receiveInstance() will swap in the exports (to Module.asm) so they can be called
|
|
receiveInstance(output['instance'], output['module']);
|
|
}
|
|
|
|
|
|
function instantiateArrayBuffer(receiver) {
|
|
return getBinaryPromise().then(function(binary) {
|
|
return WebAssembly.instantiate(binary, info);
|
|
}).then(receiver, function(reason) {
|
|
err('failed to asynchronously prepare wasm: ' + reason);
|
|
abort(reason);
|
|
});
|
|
}
|
|
|
|
// Prefer streaming instantiation if available.
|
|
function instantiateAsync() {
|
|
if (!wasmBinary &&
|
|
typeof WebAssembly.instantiateStreaming === 'function' &&
|
|
!isDataURI(wasmBinaryFile) &&
|
|
typeof fetch === 'function') {
|
|
fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function (response) {
|
|
var result = WebAssembly.instantiateStreaming(response, info);
|
|
return result.then(receiveInstantiatedSource, function(reason) {
|
|
// We expect the most common failure cause to be a bad MIME type for the binary,
|
|
// in which case falling back to ArrayBuffer instantiation should work.
|
|
err('wasm streaming compile failed: ' + reason);
|
|
err('falling back to ArrayBuffer instantiation');
|
|
instantiateArrayBuffer(receiveInstantiatedSource);
|
|
});
|
|
});
|
|
} else {
|
|
return instantiateArrayBuffer(receiveInstantiatedSource);
|
|
}
|
|
}
|
|
// User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
|
|
// to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel
|
|
// to any other async startup actions they are performing.
|
|
if (Module['instantiateWasm']) {
|
|
try {
|
|
var exports = Module['instantiateWasm'](info, receiveInstance);
|
|
return exports;
|
|
} catch(e) {
|
|
err('Module.instantiateWasm callback failed with error: ' + e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
instantiateAsync();
|
|
return {}; // no exports yet; we'll fill them in later
|
|
}
|
|
|
|
|
|
// Globals used by JS i64 conversions
|
|
var tempDouble;
|
|
var tempI64;
|
|
|
|
// === Body ===
|
|
|
|
var ASM_CONSTS = {
|
|
52684: function() {FS.mkdir('/working'); FS.mount(NODEFS, { root: '.' }, '/working');},
|
|
8571840: function() {throw 'Canceled!'},
|
|
8571979: function() {postMessage({cmd : 'processQueuedMainThreadWork'})},
|
|
8572030: function($0) {if (!ENVIRONMENT_IS_PTHREAD) { if (!PThread.pthreads[$0] || !PThread.pthreads[$0].worker) { return 0; } PThread.pthreads[$0].worker.postMessage({cmd : 'processThreadQueue'}); } else { postMessage({targetThread : $0, cmd : 'processThreadQueue'}); } return 1;},
|
|
8572398: function() {return !!(Module['canvas'])},
|
|
8572434: function() {noExitRuntime = true}
|
|
};
|
|
|
|
// Avoid creating a new array
|
|
var _readAsmConstArgsArray = [];
|
|
|
|
function readAsmConstArgs(sigPtr, buf) {
|
|
var args = _readAsmConstArgsArray;
|
|
args.length = 0;
|
|
while (1) {
|
|
var ch = HEAPU8[sigPtr++];
|
|
if (!ch) return args;
|
|
if (ch === 'd'.charCodeAt(0) || ch === 'f'.charCodeAt(0)) {
|
|
buf = alignMemory(buf, 8);
|
|
args.push(HEAPF64[(buf >> 3)]);
|
|
buf += 8;
|
|
} else if (ch === 'i'.charCodeAt(0)) {
|
|
buf = alignMemory(buf, 4);
|
|
args.push(HEAP32[(buf >> 2)]);
|
|
buf += 4;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
function _emscripten_asm_const_iii(code, sigPtr, argbuf) {
|
|
var args = readAsmConstArgs(sigPtr, argbuf);
|
|
return ASM_CONSTS[code].apply(null, args);
|
|
}function initPthreadsJS(){ PThread.initRuntime(); }
|
|
|
|
|
|
|
|
// STATICTOP = STATIC_BASE + 10203344;
|
|
/* global initializers */ if (!ENVIRONMENT_IS_PTHREAD) __ATINIT__.push({ func: function() { ___wasm_call_ctors() } });
|
|
|
|
|
|
|
|
/* no memory initializer */
|
|
// {{PRE_LIBRARY}}
|
|
|
|
|
|
function demangle(func) {
|
|
return func;
|
|
}
|
|
Module["demangle"] = demangle;
|
|
|
|
function demangleAll(text) {
|
|
var regex =
|
|
/\b_Z[\w\d_]+/g;
|
|
return text.replace(regex,
|
|
function(x) {
|
|
var y = demangle(x);
|
|
return x === y ? x : (y + ' [' + x + ']');
|
|
});
|
|
}
|
|
Module["demangleAll"] = demangleAll;
|
|
|
|
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();
|
|
}
|
|
Module["jsStackTrace"] = jsStackTrace;
|
|
|
|
function stackTrace() {
|
|
var js = jsStackTrace();
|
|
if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace']();
|
|
return demangleAll(js);
|
|
}
|
|
Module["stackTrace"] = stackTrace;
|
|
|
|
function __ZN12CPdfRenderer10SaveToFileERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE(
|
|
) {
|
|
err('missing function: _ZN12CPdfRenderer10SaveToFileERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE'); abort(-1);
|
|
}
|
|
Module["__ZN12CPdfRenderer10SaveToFileERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE"] = __ZN12CPdfRenderer10SaveToFileERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE;
|
|
|
|
function __ZN12CPdfRenderer11SetPasswordERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE(
|
|
) {
|
|
err('missing function: _ZN12CPdfRenderer11SetPasswordERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE'); abort(-1);
|
|
}
|
|
Module["__ZN12CPdfRenderer11SetPasswordERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE"] = __ZN12CPdfRenderer11SetPasswordERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE;
|
|
|
|
function __ZN12CPdfRenderer13SetDocumentIDERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE(
|
|
) {
|
|
err('missing function: _ZN12CPdfRenderer13SetDocumentIDERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE'); abort(-1);
|
|
}
|
|
Module["__ZN12CPdfRenderer13SetDocumentIDERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE"] = __ZN12CPdfRenderer13SetDocumentIDERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE;
|
|
|
|
function __ZN12CPdfRenderer13SetTempFolderERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE(
|
|
) {
|
|
err('missing function: _ZN12CPdfRenderer13SetTempFolderERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE'); abort(-1);
|
|
}
|
|
Module["__ZN12CPdfRenderer13SetTempFolderERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE"] = __ZN12CPdfRenderer13SetTempFolderERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE;
|
|
|
|
function __ZN12CPdfRenderer14SetThemesPlaceERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE(
|
|
) {
|
|
err('missing function: _ZN12CPdfRenderer14SetThemesPlaceERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE'); abort(-1);
|
|
}
|
|
Module["__ZN12CPdfRenderer14SetThemesPlaceERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE"] = __ZN12CPdfRenderer14SetThemesPlaceERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE;
|
|
|
|
function __ZN12CPdfRenderer15OnlineWordToPdfERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_(
|
|
) {
|
|
err('missing function: _ZN12CPdfRenderer15OnlineWordToPdfERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_'); abort(-1);
|
|
}
|
|
Module["__ZN12CPdfRenderer15OnlineWordToPdfERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_"] = __ZN12CPdfRenderer15OnlineWordToPdfERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_;
|
|
|
|
function __ZN12CPdfRenderer25OnlineWordToPdfFromBinaryERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_(
|
|
) {
|
|
err('missing function: _ZN12CPdfRenderer25OnlineWordToPdfFromBinaryERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_'); abort(-1);
|
|
}
|
|
Module["__ZN12CPdfRenderer25OnlineWordToPdfFromBinaryERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_"] = __ZN12CPdfRenderer25OnlineWordToPdfFromBinaryERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_;
|
|
|
|
function __ZN12CPdfRendererC1EPN7NSFonts17IApplicationFontsEb(
|
|
) {
|
|
err('missing function: _ZN12CPdfRendererC1EPN7NSFonts17IApplicationFontsEb'); abort(-1);
|
|
}
|
|
Module["__ZN12CPdfRendererC1EPN7NSFonts17IApplicationFontsEb"] = __ZN12CPdfRendererC1EPN7NSFonts17IApplicationFontsEb;
|
|
|
|
function __ZN12CPdfRendererD1Ev(
|
|
) {
|
|
err('missing function: _ZN12CPdfRendererD1Ev'); abort(-1);
|
|
}
|
|
Module["__ZN12CPdfRendererD1Ev"] = __ZN12CPdfRendererD1Ev;
|
|
|
|
function __ZN14NSDoctRenderer13CDoctrenderer18GetImagesInChangesEv(
|
|
) {
|
|
err('missing function: _ZN14NSDoctRenderer13CDoctrenderer18GetImagesInChangesEv'); abort(-1);
|
|
}
|
|
Module["__ZN14NSDoctRenderer13CDoctrenderer18GetImagesInChangesEv"] = __ZN14NSDoctRenderer13CDoctrenderer18GetImagesInChangesEv;
|
|
|
|
function __ZN14NSDoctRenderer13CDoctrenderer7ExecuteERKNSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEERS7_(
|
|
) {
|
|
err('missing function: _ZN14NSDoctRenderer13CDoctrenderer7ExecuteERKNSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEERS7_'); abort(-1);
|
|
}
|
|
Module["__ZN14NSDoctRenderer13CDoctrenderer7ExecuteERKNSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEERS7_"] = __ZN14NSDoctRenderer13CDoctrenderer7ExecuteERKNSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEERS7_;
|
|
|
|
function __ZN14NSDoctRenderer13CDoctrendererC1ERKNSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEE(
|
|
) {
|
|
err('missing function: _ZN14NSDoctRenderer13CDoctrendererC1ERKNSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEE'); abort(-1);
|
|
}
|
|
Module["__ZN14NSDoctRenderer13CDoctrendererC1ERKNSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEE"] = __ZN14NSDoctRenderer13CDoctrendererC1ERKNSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEE;
|
|
|
|
function __ZN14NSDoctRenderer13CDoctrendererD1Ev(
|
|
) {
|
|
err('missing function: _ZN14NSDoctRenderer13CDoctrendererD1Ev'); abort(-1);
|
|
}
|
|
Module["__ZN14NSDoctRenderer13CDoctrendererD1Ev"] = __ZN14NSDoctRenderer13CDoctrendererD1Ev;
|
|
|
|
function __ZN14NSHtmlRenderer17CASCHTMLRenderer316CreateOfficeFileENSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEERKS7_(
|
|
) {
|
|
err('missing function: _ZN14NSHtmlRenderer17CASCHTMLRenderer316CreateOfficeFileENSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEERKS7_'); abort(-1);
|
|
}
|
|
Module["__ZN14NSHtmlRenderer17CASCHTMLRenderer316CreateOfficeFileENSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEERKS7_"] = __ZN14NSHtmlRenderer17CASCHTMLRenderer316CreateOfficeFileENSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEERKS7_;
|
|
|
|
function __ZN14NSHtmlRenderer17CASCHTMLRenderer39CloseFileEb(
|
|
) {
|
|
err('missing function: _ZN14NSHtmlRenderer17CASCHTMLRenderer39CloseFileEb'); abort(-1);
|
|
}
|
|
Module["__ZN14NSHtmlRenderer17CASCHTMLRenderer39CloseFileEb"] = __ZN14NSHtmlRenderer17CASCHTMLRenderer39CloseFileEb;
|
|
|
|
function __ZN14NSHtmlRenderer17CASCHTMLRenderer3C1Ev(
|
|
) {
|
|
err('missing function: _ZN14NSHtmlRenderer17CASCHTMLRenderer3C1Ev'); abort(-1);
|
|
}
|
|
Module["__ZN14NSHtmlRenderer17CASCHTMLRenderer3C1Ev"] = __ZN14NSHtmlRenderer17CASCHTMLRenderer3C1Ev;
|
|
|
|
function __ZN14NSHtmlRenderer17CASCHTMLRenderer3D1Ev(
|
|
) {
|
|
err('missing function: _ZN14NSHtmlRenderer17CASCHTMLRenderer3D1Ev'); abort(-1);
|
|
}
|
|
Module["__ZN14NSHtmlRenderer17CASCHTMLRenderer3D1Ev"] = __ZN14NSHtmlRenderer17CASCHTMLRenderer3D1Ev;
|
|
|
|
function __ZN18NSUnicodeConverter17CUnicodeConverter11fromUnicodeEPKwRKjPKc(
|
|
) {
|
|
err('missing function: _ZN18NSUnicodeConverter17CUnicodeConverter11fromUnicodeEPKwRKjPKc'); abort(-1);
|
|
}
|
|
Module["__ZN18NSUnicodeConverter17CUnicodeConverter11fromUnicodeEPKwRKjPKc"] = __ZN18NSUnicodeConverter17CUnicodeConverter11fromUnicodeEPKwRKjPKc;
|
|
|
|
function __ZN18NSUnicodeConverter17CUnicodeConverter14toUnicodeExactEPKcRKjS2_(
|
|
) {
|
|
err('missing function: _ZN18NSUnicodeConverter17CUnicodeConverter14toUnicodeExactEPKcRKjS2_'); abort(-1);
|
|
}
|
|
Module["__ZN18NSUnicodeConverter17CUnicodeConverter14toUnicodeExactEPKcRKjS2_"] = __ZN18NSUnicodeConverter17CUnicodeConverter14toUnicodeExactEPKcRKjS2_;
|
|
|
|
function __ZN18NSUnicodeConverter17CUnicodeConverter14toUnicodeExactEPKcRKji(
|
|
) {
|
|
err('missing function: _ZN18NSUnicodeConverter17CUnicodeConverter14toUnicodeExactEPKcRKji'); abort(-1);
|
|
}
|
|
Module["__ZN18NSUnicodeConverter17CUnicodeConverter14toUnicodeExactEPKcRKji"] = __ZN18NSUnicodeConverter17CUnicodeConverter14toUnicodeExactEPKcRKji;
|
|
|
|
function __ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeEPKcRKjS2_(
|
|
) {
|
|
err('missing function: _ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeEPKcRKjS2_'); abort(-1);
|
|
}
|
|
Module["__ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeEPKcRKjS2_"] = __ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeEPKcRKjS2_;
|
|
|
|
function __ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeERKNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKc(
|
|
) {
|
|
err('missing function: _ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeERKNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKc'); abort(-1);
|
|
}
|
|
Module["__ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeERKNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKc"] = __ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeERKNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKc;
|
|
|
|
function __ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeERKNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEi(
|
|
) {
|
|
err('missing function: _ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeERKNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEi'); abort(-1);
|
|
}
|
|
Module["__ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeERKNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEi"] = __ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeERKNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEi;
|
|
|
|
function __ZN18NSUnicodeConverter17CUnicodeConverterC1Ev(
|
|
) {
|
|
err('missing function: _ZN18NSUnicodeConverter17CUnicodeConverterC1Ev'); abort(-1);
|
|
}
|
|
Module["__ZN18NSUnicodeConverter17CUnicodeConverterC1Ev"] = __ZN18NSUnicodeConverter17CUnicodeConverterC1Ev;
|
|
|
|
function __ZN18NSUnicodeConverter17CUnicodeConverterD1Ev(
|
|
) {
|
|
err('missing function: _ZN18NSUnicodeConverter17CUnicodeConverterD1Ev'); abort(-1);
|
|
}
|
|
Module["__ZN18NSUnicodeConverter17CUnicodeConverterD1Ev"] = __ZN18NSUnicodeConverter17CUnicodeConverterD1Ev;
|
|
|
|
function __ZN23CFileDownloader_privateC1ENSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEEb(
|
|
) {
|
|
err('missing function: _ZN23CFileDownloader_privateC1ENSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEEb'); abort(-1);
|
|
}
|
|
Module["__ZN23CFileDownloader_privateC1ENSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEEb"] = __ZN23CFileDownloader_privateC1ENSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEEb;
|
|
|
|
function __ZN8CXpsFileC1EPN7NSFonts17IApplicationFontsE(
|
|
) {
|
|
err('missing function: _ZN8CXpsFileC1EPN7NSFonts17IApplicationFontsE'); abort(-1);
|
|
}
|
|
Module["__ZN8CXpsFileC1EPN7NSFonts17IApplicationFontsE"] = __ZN8CXpsFileC1EPN7NSFonts17IApplicationFontsE;
|
|
|
|
function __ZN9CDjVuFileC1EPN7NSFonts17IApplicationFontsE(
|
|
) {
|
|
err('missing function: _ZN9CDjVuFileC1EPN7NSFonts17IApplicationFontsE'); abort(-1);
|
|
}
|
|
Module["__ZN9CDjVuFileC1EPN7NSFonts17IApplicationFontsE"] = __ZN9CDjVuFileC1EPN7NSFonts17IApplicationFontsE;
|
|
|
|
function __ZN9CHtmlFile10ConvertMhtERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_S8_(
|
|
) {
|
|
err('missing function: _ZN9CHtmlFile10ConvertMhtERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_S8_'); abort(-1);
|
|
}
|
|
Module["__ZN9CHtmlFile10ConvertMhtERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_S8_"] = __ZN9CHtmlFile10ConvertMhtERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_S8_;
|
|
|
|
function __ZN9CHtmlFile11ConvertEpubERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEERS6_S8_S8_(
|
|
) {
|
|
err('missing function: _ZN9CHtmlFile11ConvertEpubERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEERS6_S8_S8_'); abort(-1);
|
|
}
|
|
Module["__ZN9CHtmlFile11ConvertEpubERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEERS6_S8_S8_"] = __ZN9CHtmlFile11ConvertEpubERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEERS6_S8_S8_;
|
|
|
|
function __ZN9CHtmlFile7ConvertERKNSt3__26vectorINS0_12basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEENS5_IS7_EEEERKS7_SD_(
|
|
) {
|
|
err('missing function: _ZN9CHtmlFile7ConvertERKNSt3__26vectorINS0_12basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEENS5_IS7_EEEERKS7_SD_'); abort(-1);
|
|
}
|
|
Module["__ZN9CHtmlFile7ConvertERKNSt3__26vectorINS0_12basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEENS5_IS7_EEEERKS7_SD_"] = __ZN9CHtmlFile7ConvertERKNSt3__26vectorINS0_12basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEENS5_IS7_EEEERKS7_SD_;
|
|
|
|
function __ZN9CHtmlFileC1Ev(
|
|
) {
|
|
err('missing function: _ZN9CHtmlFileC1Ev'); abort(-1);
|
|
}
|
|
Module["__ZN9CHtmlFileC1Ev"] = __ZN9CHtmlFileC1Ev;
|
|
|
|
function __ZN9CHtmlFileD1Ev(
|
|
) {
|
|
err('missing function: _ZN9CHtmlFileD1Ev'); abort(-1);
|
|
}
|
|
Module["__ZN9CHtmlFileD1Ev"] = __ZN9CHtmlFileD1Ev;
|
|
|
|
function __ZN9PdfReader10CPdfReader8GetErrorEv(
|
|
) {
|
|
err('missing function: _ZN9PdfReader10CPdfReader8GetErrorEv'); abort(-1);
|
|
}
|
|
Module["__ZN9PdfReader10CPdfReader8GetErrorEv"] = __ZN9PdfReader10CPdfReader8GetErrorEv;
|
|
|
|
function __ZN9PdfReader10CPdfReaderC1EPN7NSFonts17IApplicationFontsE(
|
|
) {
|
|
err('missing function: _ZN9PdfReader10CPdfReaderC1EPN7NSFonts17IApplicationFontsE'); abort(-1);
|
|
}
|
|
Module["__ZN9PdfReader10CPdfReaderC1EPN7NSFonts17IApplicationFontsE"] = __ZN9PdfReader10CPdfReaderC1EPN7NSFonts17IApplicationFontsE;
|
|
|
|
function ___assert_fail(condition, filename, line, func) {
|
|
abort('Assertion failed: ' + UTF8ToString(condition) + ', at: ' + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']);
|
|
}
|
|
Module["___assert_fail"] = ___assert_fail;
|
|
|
|
|
|
|
|
var PROCINFO={ppid:1,pid:42,sid:42,pgid:42};
|
|
Module["PROCINFO"] = PROCINFO;
|
|
|
|
|
|
var __pthread_ptr=0;
|
|
Module["__pthread_ptr"] = __pthread_ptr;
|
|
|
|
var __pthread_is_main_runtime_thread=0;
|
|
Module["__pthread_is_main_runtime_thread"] = __pthread_is_main_runtime_thread;
|
|
|
|
var __pthread_is_main_browser_thread=0;
|
|
Module["__pthread_is_main_browser_thread"] = __pthread_is_main_browser_thread;function __register_pthread_ptr(pthreadPtr, isMainBrowserThread, isMainRuntimeThread) {
|
|
pthreadPtr = pthreadPtr|0;
|
|
isMainBrowserThread = isMainBrowserThread|0;
|
|
isMainRuntimeThread = isMainRuntimeThread|0;
|
|
__pthread_ptr = pthreadPtr;
|
|
__pthread_is_main_browser_thread = isMainBrowserThread;
|
|
__pthread_is_main_runtime_thread = isMainRuntimeThread;
|
|
}
|
|
Module["__register_pthread_ptr"] = __register_pthread_ptr;
|
|
|
|
var ERRNO_CODES={EPERM:63,ENOENT:44,ESRCH:71,EINTR:27,EIO:29,ENXIO:60,E2BIG:1,ENOEXEC:45,EBADF:8,ECHILD:12,EAGAIN:6,EWOULDBLOCK:6,ENOMEM:48,EACCES:2,EFAULT:21,ENOTBLK:105,EBUSY:10,EEXIST:20,EXDEV:75,ENODEV:43,ENOTDIR:54,EISDIR:31,EINVAL:28,ENFILE:41,EMFILE:33,ENOTTY:59,ETXTBSY:74,EFBIG:22,ENOSPC:51,ESPIPE:70,EROFS:69,EMLINK:34,EPIPE:64,EDOM:18,ERANGE:68,ENOMSG:49,EIDRM:24,ECHRNG:106,EL2NSYNC:156,EL3HLT:107,EL3RST:108,ELNRNG:109,EUNATCH:110,ENOCSI:111,EL2HLT:112,EDEADLK:16,ENOLCK:46,EBADE:113,EBADR:114,EXFULL:115,ENOANO:104,EBADRQC:103,EBADSLT:102,EDEADLOCK:16,EBFONT:101,ENOSTR:100,ENODATA:116,ETIME:117,ENOSR:118,ENONET:119,ENOPKG:120,EREMOTE:121,ENOLINK:47,EADV:122,ESRMNT:123,ECOMM:124,EPROTO:65,EMULTIHOP:36,EDOTDOT:125,EBADMSG:9,ENOTUNIQ:126,EBADFD:127,EREMCHG:128,ELIBACC:129,ELIBBAD:130,ELIBSCN:131,ELIBMAX:132,ELIBEXEC:133,ENOSYS:52,ENOTEMPTY:55,ENAMETOOLONG:37,ELOOP:32,EOPNOTSUPP:138,EPFNOSUPPORT:139,ECONNRESET:15,ENOBUFS:42,EAFNOSUPPORT:5,EPROTOTYPE:67,ENOTSOCK:57,ENOPROTOOPT:50,ESHUTDOWN:140,ECONNREFUSED:14,EADDRINUSE:3,ECONNABORTED:13,ENETUNREACH:40,ENETDOWN:38,ETIMEDOUT:73,EHOSTDOWN:142,EHOSTUNREACH:23,EINPROGRESS:26,EALREADY:7,EDESTADDRREQ:17,EMSGSIZE:35,EPROTONOSUPPORT:66,ESOCKTNOSUPPORT:137,EADDRNOTAVAIL:4,ENETRESET:39,EISCONN:30,ENOTCONN:53,ETOOMANYREFS:141,EUSERS:136,EDQUOT:19,ESTALE:72,ENOTSUP:138,ENOMEDIUM:148,EILSEQ:25,EOVERFLOW:61,ECANCELED:11,ENOTRECOVERABLE:56,EOWNERDEAD:62,ESTRPIPE:135};
|
|
Module["ERRNO_CODES"] = ERRNO_CODES;
|
|
|
|
|
|
var __main_thread_futex_wait_address=10204352;
|
|
Module["__main_thread_futex_wait_address"] = __main_thread_futex_wait_address;function _emscripten_futex_wake(addr, count) {
|
|
if (addr <= 0 || addr > HEAP8.length || addr&3 != 0 || count < 0) return -28;
|
|
if (count == 0) return 0;
|
|
// Waking (at least) INT_MAX waiters is defined to mean wake all callers.
|
|
// For Atomics.notify() API Infinity is to be passed in that case.
|
|
if (count >= 2147483647) count = Infinity;
|
|
// dump('futex_wake addr:' + addr + ' by thread: ' + _pthread_self() + (ENVIRONMENT_IS_PTHREAD?'(pthread)':'') + '\n');
|
|
|
|
// See if main thread is waiting on this address? If so, wake it up by resetting its wake location to zero.
|
|
// Note that this is not a fair procedure, since we always wake main thread first before any workers, so
|
|
// this scheme does not adhere to real queue-based waiting.
|
|
var mainThreadWaitAddress = Atomics.load(HEAP32, __main_thread_futex_wait_address >> 2);
|
|
var mainThreadWoken = 0;
|
|
if (mainThreadWaitAddress == addr) {
|
|
var loadedAddr = Atomics.compareExchange(HEAP32, __main_thread_futex_wait_address >> 2, mainThreadWaitAddress, 0);
|
|
if (loadedAddr == mainThreadWaitAddress) {
|
|
--count;
|
|
mainThreadWoken = 1;
|
|
if (count <= 0) return 1;
|
|
}
|
|
}
|
|
|
|
// Wake any workers waiting on this address.
|
|
var ret = Atomics.notify(HEAP32, addr >> 2, count);
|
|
if (ret >= 0) return ret + mainThreadWoken;
|
|
throw 'Atomics.notify returned an unexpected value ' + ret;
|
|
}
|
|
Module["_emscripten_futex_wake"] = _emscripten_futex_wake;
|
|
|
|
function __kill_thread(pthread_ptr) {
|
|
if (ENVIRONMENT_IS_PTHREAD) throw 'Internal Error! _kill_thread() can only ever be called from main application thread!';
|
|
if (!pthread_ptr) throw 'Internal Error! Null pthread_ptr in _kill_thread!';
|
|
HEAP32[(((pthread_ptr)+(24))>>2)]=0;
|
|
var pthread = PThread.pthreads[pthread_ptr];
|
|
pthread.worker.terminate();
|
|
PThread.freeThreadData(pthread);
|
|
// The worker was completely nuked (not just the pthread execution it was hosting), so remove it from running workers
|
|
// but don't put it back to the pool.
|
|
PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(pthread.worker), 1); // Not a running Worker anymore.
|
|
pthread.worker.pthread = undefined;
|
|
}
|
|
Module["__kill_thread"] = __kill_thread;
|
|
|
|
function __cancel_thread(pthread_ptr) {
|
|
if (ENVIRONMENT_IS_PTHREAD) throw 'Internal Error! _cancel_thread() can only ever be called from main application thread!';
|
|
if (!pthread_ptr) throw 'Internal Error! Null pthread_ptr in _cancel_thread!';
|
|
var pthread = PThread.pthreads[pthread_ptr];
|
|
pthread.worker.postMessage({ 'cmd': 'cancel' });
|
|
}
|
|
Module["__cancel_thread"] = __cancel_thread;
|
|
|
|
function __cleanup_thread(pthread_ptr) {
|
|
if (ENVIRONMENT_IS_PTHREAD) throw 'Internal Error! _cleanup_thread() can only ever be called from main application thread!';
|
|
if (!pthread_ptr) throw 'Internal Error! Null pthread_ptr in _cleanup_thread!';
|
|
HEAP32[(((pthread_ptr)+(24))>>2)]=0;
|
|
var pthread = PThread.pthreads[pthread_ptr];
|
|
if (pthread) {
|
|
var worker = pthread.worker;
|
|
PThread.returnWorkerToPool(worker);
|
|
}
|
|
}
|
|
Module["__cleanup_thread"] = __cleanup_thread;var PThread={MAIN_THREAD_ID:1,mainThreadInfo:{schedPolicy:0,schedPrio:0},preallocatedWorkers:[],unusedWorkers:[],runningWorkers:[],initRuntime:function() {
|
|
// Pass the thread address inside the asm.js scope to store it for fast access that avoids the need for a FFI out.
|
|
// Global constructors trying to access this value will read the wrong value, but that is UB anyway.
|
|
__register_pthread_ptr(PThread.mainThreadBlock, /*isMainBrowserThread=*/!ENVIRONMENT_IS_WORKER, /*isMainRuntimeThread=*/1);
|
|
_emscripten_register_main_browser_thread_id(PThread.mainThreadBlock);
|
|
},initMainThreadBlock:function() {
|
|
if (ENVIRONMENT_IS_PTHREAD) return undefined;
|
|
|
|
|
|
PThread.mainThreadBlock = 10203568;
|
|
|
|
for (var i = 0; i < 244/4; ++i) HEAPU32[PThread.mainThreadBlock/4+i] = 0;
|
|
|
|
// The pthread struct has a field that points to itself - this is used as a magic ID to detect whether the pthread_t
|
|
// structure is 'alive'.
|
|
HEAP32[(((PThread.mainThreadBlock)+(24))>>2)]=PThread.mainThreadBlock;
|
|
|
|
// pthread struct robust_list head should point to itself.
|
|
var headPtr = PThread.mainThreadBlock + 168;
|
|
HEAP32[((headPtr)>>2)]=headPtr;
|
|
|
|
// Allocate memory for thread-local storage.
|
|
var tlsMemory = 10203824;
|
|
for (var i = 0; i < 128; ++i) HEAPU32[tlsMemory/4+i] = 0;
|
|
Atomics.store(HEAPU32, (PThread.mainThreadBlock + 116 ) >> 2, tlsMemory); // Init thread-local-storage memory array.
|
|
Atomics.store(HEAPU32, (PThread.mainThreadBlock + 52 ) >> 2, PThread.mainThreadBlock); // Main thread ID.
|
|
Atomics.store(HEAPU32, (PThread.mainThreadBlock + 56 ) >> 2, PROCINFO.pid); // Process ID.
|
|
|
|
},initWorker:function() {
|
|
},pthreads:{},exitHandlers:null,setThreadStatus:function() {},runExitHandlers:function() {
|
|
if (PThread.exitHandlers !== null) {
|
|
while (PThread.exitHandlers.length > 0) {
|
|
PThread.exitHandlers.pop()();
|
|
}
|
|
PThread.exitHandlers = null;
|
|
}
|
|
|
|
// Call into the musl function that runs destructors of all thread-specific data.
|
|
if (ENVIRONMENT_IS_PTHREAD && threadInfoStruct) ___pthread_tsd_run_dtors();
|
|
},threadExit:function(exitCode) {
|
|
var tb = _pthread_self();
|
|
if (tb) { // If we haven't yet exited?
|
|
Atomics.store(HEAPU32, (tb + 4 ) >> 2, exitCode);
|
|
// When we publish this, the main thread is free to deallocate the thread object and we are done.
|
|
// Therefore set threadInfoStruct = 0; above to 'release' the object in this worker thread.
|
|
Atomics.store(HEAPU32, (tb + 0 ) >> 2, 1);
|
|
|
|
// Disable all cancellation so that executing the cleanup handlers won't trigger another JS
|
|
// canceled exception to be thrown.
|
|
Atomics.store(HEAPU32, (tb + 72 ) >> 2, 1/*PTHREAD_CANCEL_DISABLE*/);
|
|
Atomics.store(HEAPU32, (tb + 76 ) >> 2, 0/*PTHREAD_CANCEL_DEFERRED*/);
|
|
PThread.runExitHandlers();
|
|
|
|
_emscripten_futex_wake(tb + 0, 2147483647);
|
|
__register_pthread_ptr(0, 0, 0); // Unregister the thread block also inside the asm.js scope.
|
|
threadInfoStruct = 0;
|
|
if (ENVIRONMENT_IS_PTHREAD) {
|
|
// Note: in theory we would like to return any offscreen canvases back to the main thread,
|
|
// but if we ever fetched a rendering context for them that would not be valid, so we don't try.
|
|
postMessage({ 'cmd': 'exit' });
|
|
}
|
|
}
|
|
},threadCancel:function() {
|
|
PThread.runExitHandlers();
|
|
Atomics.store(HEAPU32, (threadInfoStruct + 4 ) >> 2, -1/*PTHREAD_CANCELED*/);
|
|
Atomics.store(HEAPU32, (threadInfoStruct + 0 ) >> 2, 1); // Mark the thread as no longer running.
|
|
_emscripten_futex_wake(threadInfoStruct + 0, 2147483647); // wake all threads
|
|
threadInfoStruct = selfThreadId = 0; // Not hosting a pthread anymore in this worker, reset the info structures to null.
|
|
__register_pthread_ptr(0, 0, 0); // Unregister the thread block also inside the asm.js scope.
|
|
postMessage({ 'cmd': 'cancelDone' });
|
|
},terminateAllThreads:function() {
|
|
for (var t in PThread.pthreads) {
|
|
var pthread = PThread.pthreads[t];
|
|
if (pthread && pthread.worker) {
|
|
PThread.returnWorkerToPool(pthread.worker);
|
|
}
|
|
}
|
|
PThread.pthreads = {};
|
|
|
|
for (var i = 0; i < PThread.preallocatedWorkers.length; ++i) {
|
|
var worker = PThread.preallocatedWorkers[i];
|
|
worker.terminate();
|
|
}
|
|
PThread.preallocatedWorkers = [];
|
|
|
|
for (var i = 0; i < PThread.unusedWorkers.length; ++i) {
|
|
var worker = PThread.unusedWorkers[i];
|
|
worker.terminate();
|
|
}
|
|
PThread.unusedWorkers = [];
|
|
|
|
for (var i = 0; i < PThread.runningWorkers.length; ++i) {
|
|
var worker = PThread.runningWorkers[i];
|
|
var pthread = worker.pthread;
|
|
PThread.freeThreadData(pthread);
|
|
worker.terminate();
|
|
}
|
|
PThread.runningWorkers = [];
|
|
},freeThreadData:function(pthread) {
|
|
if (!pthread) return;
|
|
if (pthread.threadInfoStruct) {
|
|
var tlsMemory = HEAP32[(((pthread.threadInfoStruct)+(116))>>2)];
|
|
HEAP32[(((pthread.threadInfoStruct)+(116))>>2)]=0;
|
|
_free(tlsMemory);
|
|
_free(pthread.threadInfoStruct);
|
|
}
|
|
pthread.threadInfoStruct = 0;
|
|
if (pthread.allocatedOwnStack && pthread.stackBase) _free(pthread.stackBase);
|
|
pthread.stackBase = 0;
|
|
if (pthread.worker) pthread.worker.pthread = null;
|
|
},returnWorkerToPool:function(worker) {
|
|
delete PThread.pthreads[worker.pthread.thread];
|
|
//Note: worker is intentionally not terminated so the pool can dynamically grow.
|
|
PThread.unusedWorkers.push(worker);
|
|
PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1); // Not a running Worker anymore
|
|
PThread.freeThreadData(worker.pthread);
|
|
worker.pthread = undefined; // Detach the worker from the pthread object, and return it to the worker pool as an unused worker.
|
|
},receiveObjectTransfer:function(data) {
|
|
},allocateUnusedWorkers:function(numWorkers, onFinishedLoading) {
|
|
if (typeof SharedArrayBuffer === 'undefined') return; // No multithreading support, no-op.
|
|
|
|
var workers = [];
|
|
|
|
var numWorkersToCreate = numWorkers;
|
|
if (PThread.preallocatedWorkers.length > 0) {
|
|
var workersUsed = Math.min(PThread.preallocatedWorkers.length, numWorkers);
|
|
workers = workers.concat(PThread.preallocatedWorkers.splice(0, workersUsed));
|
|
numWorkersToCreate -= workersUsed;
|
|
}
|
|
if (numWorkersToCreate > 0) {
|
|
workers = workers.concat(PThread.createNewWorkers(numWorkersToCreate));
|
|
}
|
|
|
|
// Add the listeners.
|
|
PThread.attachListenerToWorkers(workers, onFinishedLoading);
|
|
|
|
// Load the wasm module into the worker.
|
|
for (var i = 0; i < numWorkers; ++i) {
|
|
var worker = workers[i];
|
|
|
|
|
|
// Ask the new worker to load up the Emscripten-compiled page. This is a heavy operation.
|
|
worker.postMessage({
|
|
'cmd': 'load',
|
|
// If the application main .js file was loaded from a Blob, then it is not possible
|
|
// to access the URL of the current script that could be passed to a Web Worker so that
|
|
// it could load up the same file. In that case, developer must either deliver the Blob
|
|
// object in Module['mainScriptUrlOrBlob'], or a URL to it, so that pthread Workers can
|
|
// independently load up the same main application file.
|
|
'urlOrBlob': Module['mainScriptUrlOrBlob'] || _scriptDir,
|
|
'wasmMemory': wasmMemory,
|
|
'wasmModule': wasmModule,
|
|
'DYNAMIC_BASE': DYNAMIC_BASE,
|
|
'DYNAMICTOP_PTR': DYNAMICTOP_PTR
|
|
});
|
|
PThread.unusedWorkers.push(worker);
|
|
}
|
|
},attachListenerToWorkers:function(workers, onFinishedLoading) {
|
|
var numWorkersLoaded = 0;
|
|
var numWorkers = workers.length;
|
|
for (var i = 0; i < numWorkers; ++i) {
|
|
var worker = workers[i];
|
|
(function(worker) {
|
|
worker.onmessage = function(e) {
|
|
var d = e['data'];
|
|
var cmd = d['cmd'];
|
|
// Sometimes we need to backproxy events to the calling thread (e.g. HTML5 DOM events handlers such as emscripten_set_mousemove_callback()), so keep track in a globally accessible variable about the thread that initiated the proxying.
|
|
if (worker.pthread) PThread.currentProxiedOperationCallerThread = worker.pthread.threadInfoStruct;
|
|
|
|
// If this message is intended to a recipient that is not the main thread, forward it to the target thread.
|
|
if (d['targetThread'] && d['targetThread'] != _pthread_self()) {
|
|
var thread = PThread.pthreads[d.targetThread];
|
|
if (thread) {
|
|
thread.worker.postMessage(e.data, d['transferList']);
|
|
} else {
|
|
console.error('Internal error! Worker sent a message "' + cmd + '" to target pthread ' + d['targetThread'] + ', but that thread no longer exists!');
|
|
}
|
|
PThread.currentProxiedOperationCallerThread = undefined;
|
|
return;
|
|
}
|
|
|
|
if (cmd === 'processQueuedMainThreadWork') {
|
|
// TODO: Must post message to main Emscripten thread in PROXY_TO_WORKER mode.
|
|
_emscripten_main_thread_process_queued_calls();
|
|
} else if (cmd === 'spawnThread') {
|
|
__spawn_thread(e.data);
|
|
} else if (cmd === 'cleanupThread') {
|
|
__cleanup_thread(d['thread']);
|
|
} else if (cmd === 'killThread') {
|
|
__kill_thread(d['thread']);
|
|
} else if (cmd === 'cancelThread') {
|
|
__cancel_thread(d['thread']);
|
|
} else if (cmd === 'loaded') {
|
|
worker.loaded = true;
|
|
// If this Worker is already pending to start running a thread, launch the thread now
|
|
if (worker.runPthread) {
|
|
worker.runPthread();
|
|
delete worker.runPthread;
|
|
}
|
|
++numWorkersLoaded;
|
|
if (numWorkersLoaded === numWorkers && onFinishedLoading) {
|
|
onFinishedLoading();
|
|
}
|
|
} else if (cmd === 'print') {
|
|
out('Thread ' + d['threadId'] + ': ' + d['text']);
|
|
} else if (cmd === 'printErr') {
|
|
err('Thread ' + d['threadId'] + ': ' + d['text']);
|
|
} else if (cmd === 'alert') {
|
|
alert('Thread ' + d['threadId'] + ': ' + d['text']);
|
|
} else if (cmd === 'exit') {
|
|
var detached = worker.pthread && Atomics.load(HEAPU32, (worker.pthread.thread + 80) >> 2);
|
|
if (detached) {
|
|
PThread.returnWorkerToPool(worker);
|
|
}
|
|
} else if (cmd === 'exitProcess') {
|
|
// A pthread has requested to exit the whole application process (runtime).
|
|
noExitRuntime = false;
|
|
try {
|
|
exit(d['returnCode']);
|
|
} catch (e) {
|
|
if (e instanceof ExitStatus) return;
|
|
throw e;
|
|
}
|
|
} else if (cmd === 'cancelDone') {
|
|
PThread.returnWorkerToPool(worker);
|
|
} else if (cmd === 'objectTransfer') {
|
|
PThread.receiveObjectTransfer(e.data);
|
|
} else if (e.data.target === 'setimmediate') {
|
|
worker.postMessage(e.data); // Worker wants to postMessage() to itself to implement setImmediate() emulation.
|
|
} else {
|
|
err("worker sent an unknown command " + cmd);
|
|
}
|
|
PThread.currentProxiedOperationCallerThread = undefined;
|
|
};
|
|
|
|
worker.onerror = function(e) {
|
|
err('pthread sent an error! ' + e.filename + ':' + e.lineno + ': ' + e.message);
|
|
};
|
|
|
|
if (ENVIRONMENT_HAS_NODE) {
|
|
worker.on('message', function(data) {
|
|
worker.onmessage({ data: data });
|
|
});
|
|
worker.on('error', function(data) {
|
|
worker.onerror(data);
|
|
});
|
|
worker.on('exit', function(data) {
|
|
console.log('worker exited - TODO: update the worker queue?');
|
|
});
|
|
}
|
|
}(worker));
|
|
} // for each worker
|
|
},createNewWorkers:function(numWorkers) {
|
|
// Creates new workers with the discovered pthread worker file.
|
|
if (typeof SharedArrayBuffer === 'undefined') return []; // No multithreading support, no-op.
|
|
var pthreadMainJs = "x2t.worker.js";
|
|
// Allow HTML module to configure the location where the 'worker.js' file will be loaded from,
|
|
// via Module.locateFile() function. If not specified, then the default URL 'worker.js' relative
|
|
// to the main html file is loaded.
|
|
pthreadMainJs = locateFile(pthreadMainJs);
|
|
var newWorkers = [];
|
|
for (var i = 0; i < numWorkers; ++i) {
|
|
newWorkers.push(new Worker(pthreadMainJs));
|
|
}
|
|
return newWorkers;
|
|
},getNewWorker:function() {
|
|
if (PThread.unusedWorkers.length == 0) PThread.allocateUnusedWorkers(1);
|
|
if (PThread.unusedWorkers.length > 0) return PThread.unusedWorkers.pop();
|
|
else return null;
|
|
},busySpinWait:function(msecs) {
|
|
var t = performance.now() + msecs;
|
|
while(performance.now() < t) {
|
|
;
|
|
}
|
|
}};
|
|
Module["PThread"] = PThread;function ___call_main(argc, argv) {
|
|
var returnCode = _main(argc, argv);
|
|
if (!noExitRuntime) postMessage({ 'cmd': 'exitProcess', 'returnCode': returnCode });
|
|
return returnCode;
|
|
}
|
|
Module["___call_main"] = ___call_main;
|
|
|
|
|
|
|
|
function _emscripten_get_now() { abort() }
|
|
Module["_emscripten_get_now"] = _emscripten_get_now;
|
|
|
|
function _emscripten_get_now_is_monotonic() {
|
|
// return whether emscripten_get_now is guaranteed monotonic; the Date.now
|
|
// implementation is not :(
|
|
return (0
|
|
|| ENVIRONMENT_IS_NODE
|
|
|| (typeof dateNow !== 'undefined')
|
|
|| (typeof performance === 'object' && performance && typeof performance['now'] === 'function')
|
|
);
|
|
}
|
|
Module["_emscripten_get_now_is_monotonic"] = _emscripten_get_now_is_monotonic;
|
|
|
|
function ___setErrNo(value) {
|
|
if (Module['___errno_location']) HEAP32[((Module['___errno_location']())>>2)]=value;
|
|
return value;
|
|
}
|
|
Module["___setErrNo"] = ___setErrNo;function _clock_gettime(clk_id, tp) {
|
|
// int clock_gettime(clockid_t clk_id, struct timespec *tp);
|
|
var now;
|
|
if (clk_id === 0) {
|
|
now = Date.now();
|
|
} else if (clk_id === 1 && _emscripten_get_now_is_monotonic()) {
|
|
now = _emscripten_get_now();
|
|
} else {
|
|
___setErrNo(28);
|
|
return -1;
|
|
}
|
|
HEAP32[((tp)>>2)]=(now/1000)|0; // seconds
|
|
HEAP32[(((tp)+(4))>>2)]=((now % 1000)*1000*1000)|0; // nanoseconds
|
|
return 0;
|
|
}
|
|
Module["_clock_gettime"] = _clock_gettime;function ___clock_gettime(a0,a1
|
|
) {
|
|
return _clock_gettime(a0,a1);
|
|
}
|
|
Module["___clock_gettime"] = ___clock_gettime;
|
|
|
|
function ___cxa_allocate_exception(size) {
|
|
return _malloc(size);
|
|
}
|
|
Module["___cxa_allocate_exception"] = ___cxa_allocate_exception;
|
|
|
|
|
|
function _atexit(func, arg) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(1, 1, func, arg);
|
|
|
|
__ATEXIT__.unshift({ func: func, arg: arg });
|
|
}
|
|
|
|
Module["_atexit"] = _atexit;function ___cxa_atexit(
|
|
) {
|
|
return _atexit.apply(null, arguments)
|
|
}
|
|
Module["___cxa_atexit"] = ___cxa_atexit;
|
|
|
|
|
|
var ___exception_caught= [];
|
|
Module["___exception_caught"] = ___exception_caught;
|
|
|
|
|
|
var ___exception_infos={};
|
|
Module["___exception_infos"] = ___exception_infos;function ___exception_deAdjust(adjusted) {
|
|
if (!adjusted || ___exception_infos[adjusted]) return adjusted;
|
|
for (var key in ___exception_infos) {
|
|
var ptr = +key; // the iteration key is a string, and if we throw this, it must be an integer as that is what we look for
|
|
var adj = ___exception_infos[ptr].adjusted;
|
|
var len = adj.length;
|
|
for (var i = 0; i < len; i++) {
|
|
if (adj[i] === adjusted) {
|
|
return ptr;
|
|
}
|
|
}
|
|
}
|
|
return adjusted;
|
|
}
|
|
Module["___exception_deAdjust"] = ___exception_deAdjust;
|
|
|
|
var ___exception_last=0;
|
|
Module["___exception_last"] = ___exception_last;function ___cxa_rethrow() {
|
|
var ptr = ___exception_caught.pop();
|
|
ptr = ___exception_deAdjust(ptr);
|
|
if (!___exception_infos[ptr].rethrown) {
|
|
// Only pop if the corresponding push was through rethrow_primary_exception
|
|
___exception_caught.push(ptr);
|
|
___exception_infos[ptr].rethrown = true;
|
|
}
|
|
___exception_last = ptr;
|
|
throw ptr;
|
|
}
|
|
Module["___cxa_rethrow"] = ___cxa_rethrow;
|
|
|
|
function ___cxa_throw(ptr, type, destructor) {
|
|
___exception_infos[ptr] = {
|
|
ptr: ptr,
|
|
adjusted: [ptr],
|
|
type: type,
|
|
destructor: destructor,
|
|
refcount: 0,
|
|
caught: false,
|
|
rethrown: false
|
|
};
|
|
___exception_last = ptr;
|
|
if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) {
|
|
__ZSt18uncaught_exceptionv.uncaught_exceptions = 1;
|
|
} else {
|
|
__ZSt18uncaught_exceptionv.uncaught_exceptions++;
|
|
}
|
|
throw ptr;
|
|
}
|
|
Module["___cxa_throw"] = ___cxa_throw;
|
|
|
|
function ___lock() {}
|
|
Module["___lock"] = ___lock;
|
|
|
|
function ___map_file(pathname, size) {
|
|
___setErrNo(63);
|
|
return -1;
|
|
}
|
|
Module["___map_file"] = ___map_file;
|
|
|
|
|
|
|
|
var PATH={splitPath:function(filename) {
|
|
var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
|
|
return splitPathRe.exec(filename).slice(1);
|
|
},normalizeArray:function(parts, allowAboveRoot) {
|
|
// if the path tries to go above the root, `up` ends up > 0
|
|
var up = 0;
|
|
for (var i = parts.length - 1; i >= 0; i--) {
|
|
var last = parts[i];
|
|
if (last === '.') {
|
|
parts.splice(i, 1);
|
|
} else if (last === '..') {
|
|
parts.splice(i, 1);
|
|
up++;
|
|
} else if (up) {
|
|
parts.splice(i, 1);
|
|
up--;
|
|
}
|
|
}
|
|
// if the path is allowed to go above the root, restore leading ..s
|
|
if (allowAboveRoot) {
|
|
for (; up; up--) {
|
|
parts.unshift('..');
|
|
}
|
|
}
|
|
return parts;
|
|
},normalize:function(path) {
|
|
var isAbsolute = path.charAt(0) === '/',
|
|
trailingSlash = path.substr(-1) === '/';
|
|
// Normalize the path
|
|
path = PATH.normalizeArray(path.split('/').filter(function(p) {
|
|
return !!p;
|
|
}), !isAbsolute).join('/');
|
|
if (!path && !isAbsolute) {
|
|
path = '.';
|
|
}
|
|
if (path && trailingSlash) {
|
|
path += '/';
|
|
}
|
|
return (isAbsolute ? '/' : '') + path;
|
|
},dirname:function(path) {
|
|
var result = PATH.splitPath(path),
|
|
root = result[0],
|
|
dir = result[1];
|
|
if (!root && !dir) {
|
|
// No dirname whatsoever
|
|
return '.';
|
|
}
|
|
if (dir) {
|
|
// It has a dirname, strip trailing slash
|
|
dir = dir.substr(0, dir.length - 1);
|
|
}
|
|
return root + dir;
|
|
},basename:function(path) {
|
|
// EMSCRIPTEN return '/'' for '/', not an empty string
|
|
if (path === '/') return '/';
|
|
var lastSlash = path.lastIndexOf('/');
|
|
if (lastSlash === -1) return path;
|
|
return path.substr(lastSlash+1);
|
|
},extname:function(path) {
|
|
return PATH.splitPath(path)[3];
|
|
},join:function() {
|
|
var paths = Array.prototype.slice.call(arguments, 0);
|
|
return PATH.normalize(paths.join('/'));
|
|
},join2:function(l, r) {
|
|
return PATH.normalize(l + '/' + r);
|
|
}};
|
|
Module["PATH"] = PATH;
|
|
|
|
|
|
var PATH_FS={resolve:function() {
|
|
var resolvedPath = '',
|
|
resolvedAbsolute = false;
|
|
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
|
var path = (i >= 0) ? arguments[i] : FS.cwd();
|
|
// Skip empty and invalid entries
|
|
if (typeof path !== 'string') {
|
|
throw new TypeError('Arguments to path.resolve must be strings');
|
|
} else if (!path) {
|
|
return ''; // an invalid portion invalidates the whole thing
|
|
}
|
|
resolvedPath = path + '/' + resolvedPath;
|
|
resolvedAbsolute = path.charAt(0) === '/';
|
|
}
|
|
// At this point the path should be resolved to a full absolute path, but
|
|
// handle relative paths to be safe (might happen when process.cwd() fails)
|
|
resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) {
|
|
return !!p;
|
|
}), !resolvedAbsolute).join('/');
|
|
return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
|
|
},relative:function(from, to) {
|
|
from = PATH_FS.resolve(from).substr(1);
|
|
to = PATH_FS.resolve(to).substr(1);
|
|
function trim(arr) {
|
|
var start = 0;
|
|
for (; start < arr.length; start++) {
|
|
if (arr[start] !== '') break;
|
|
}
|
|
var end = arr.length - 1;
|
|
for (; end >= 0; end--) {
|
|
if (arr[end] !== '') break;
|
|
}
|
|
if (start > end) return [];
|
|
return arr.slice(start, end - start + 1);
|
|
}
|
|
var fromParts = trim(from.split('/'));
|
|
var toParts = trim(to.split('/'));
|
|
var length = Math.min(fromParts.length, toParts.length);
|
|
var samePartsLength = length;
|
|
for (var i = 0; i < length; i++) {
|
|
if (fromParts[i] !== toParts[i]) {
|
|
samePartsLength = i;
|
|
break;
|
|
}
|
|
}
|
|
var outputParts = [];
|
|
for (var i = samePartsLength; i < fromParts.length; i++) {
|
|
outputParts.push('..');
|
|
}
|
|
outputParts = outputParts.concat(toParts.slice(samePartsLength));
|
|
return outputParts.join('/');
|
|
}};
|
|
Module["PATH_FS"] = PATH_FS;
|
|
|
|
var TTY={ttys:[],init:function () {
|
|
// https://github.com/emscripten-core/emscripten/pull/1555
|
|
// if (ENVIRONMENT_IS_NODE) {
|
|
// // currently, FS.init does not distinguish if process.stdin is a file or TTY
|
|
// // device, it always assumes it's a TTY device. because of this, we're forcing
|
|
// // process.stdin to UTF8 encoding to at least make stdin reading compatible
|
|
// // with text files until FS.init can be refactored.
|
|
// process['stdin']['setEncoding']('utf8');
|
|
// }
|
|
},shutdown:function() {
|
|
// https://github.com/emscripten-core/emscripten/pull/1555
|
|
// if (ENVIRONMENT_IS_NODE) {
|
|
// // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
|
|
// // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
|
|
// // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
|
|
// // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
|
|
// // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
|
|
// process['stdin']['pause']();
|
|
// }
|
|
},register:function(dev, ops) {
|
|
TTY.ttys[dev] = { input: [], output: [], ops: ops };
|
|
FS.registerDevice(dev, TTY.stream_ops);
|
|
},stream_ops:{open:function(stream) {
|
|
var tty = TTY.ttys[stream.node.rdev];
|
|
if (!tty) {
|
|
throw new FS.ErrnoError(43);
|
|
}
|
|
stream.tty = tty;
|
|
stream.seekable = false;
|
|
},close:function(stream) {
|
|
// flush any pending line data
|
|
stream.tty.ops.flush(stream.tty);
|
|
},flush:function(stream) {
|
|
stream.tty.ops.flush(stream.tty);
|
|
},read:function(stream, buffer, offset, length, pos /* ignored */) {
|
|
if (!stream.tty || !stream.tty.ops.get_char) {
|
|
throw new FS.ErrnoError(60);
|
|
}
|
|
var bytesRead = 0;
|
|
for (var i = 0; i < length; i++) {
|
|
var result;
|
|
try {
|
|
result = stream.tty.ops.get_char(stream.tty);
|
|
} catch (e) {
|
|
throw new FS.ErrnoError(29);
|
|
}
|
|
if (result === undefined && bytesRead === 0) {
|
|
throw new FS.ErrnoError(6);
|
|
}
|
|
if (result === null || result === undefined) break;
|
|
bytesRead++;
|
|
buffer[offset+i] = result;
|
|
}
|
|
if (bytesRead) {
|
|
stream.node.timestamp = Date.now();
|
|
}
|
|
return bytesRead;
|
|
},write:function(stream, buffer, offset, length, pos) {
|
|
if (!stream.tty || !stream.tty.ops.put_char) {
|
|
throw new FS.ErrnoError(60);
|
|
}
|
|
try {
|
|
for (var i = 0; i < length; i++) {
|
|
stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
|
|
}
|
|
} catch (e) {
|
|
throw new FS.ErrnoError(29);
|
|
}
|
|
if (length) {
|
|
stream.node.timestamp = Date.now();
|
|
}
|
|
return i;
|
|
}},default_tty_ops:{get_char:function(tty) {
|
|
if (!tty.input.length) {
|
|
var result = null;
|
|
if (ENVIRONMENT_IS_NODE) {
|
|
// we will read data by chunks of BUFSIZE
|
|
var BUFSIZE = 256;
|
|
var buf = Buffer.alloc ? Buffer.alloc(BUFSIZE) : new Buffer(BUFSIZE);
|
|
var bytesRead = 0;
|
|
|
|
try {
|
|
bytesRead = nodeFS.readSync(process.stdin.fd, buf, 0, BUFSIZE, null);
|
|
} catch(e) {
|
|
// Cross-platform differences: on Windows, reading EOF throws an exception, but on other OSes,
|
|
// reading EOF returns 0. Uniformize behavior by treating the EOF exception to return 0.
|
|
if (e.toString().indexOf('EOF') != -1) bytesRead = 0;
|
|
else throw e;
|
|
}
|
|
|
|
if (bytesRead > 0) {
|
|
result = buf.slice(0, bytesRead).toString('utf-8');
|
|
} else {
|
|
result = null;
|
|
}
|
|
} else
|
|
if (typeof window != 'undefined' &&
|
|
typeof window.prompt == 'function') {
|
|
// Browser.
|
|
result = window.prompt('Input: '); // returns null on cancel
|
|
if (result !== null) {
|
|
result += '\n';
|
|
}
|
|
} else if (typeof readline == 'function') {
|
|
// Command line.
|
|
result = readline();
|
|
if (result !== null) {
|
|
result += '\n';
|
|
}
|
|
}
|
|
if (!result) {
|
|
return null;
|
|
}
|
|
tty.input = intArrayFromString(result, true);
|
|
}
|
|
return tty.input.shift();
|
|
},put_char:function(tty, val) {
|
|
if (val === null || val === 10) {
|
|
out(UTF8ArrayToString(tty.output, 0));
|
|
tty.output = [];
|
|
} else {
|
|
if (val != 0) tty.output.push(val); // val == 0 would cut text output off in the middle.
|
|
}
|
|
},flush:function(tty) {
|
|
if (tty.output && tty.output.length > 0) {
|
|
out(UTF8ArrayToString(tty.output, 0));
|
|
tty.output = [];
|
|
}
|
|
}},default_tty1_ops:{put_char:function(tty, val) {
|
|
if (val === null || val === 10) {
|
|
err(UTF8ArrayToString(tty.output, 0));
|
|
tty.output = [];
|
|
} else {
|
|
if (val != 0) tty.output.push(val);
|
|
}
|
|
},flush:function(tty) {
|
|
if (tty.output && tty.output.length > 0) {
|
|
err(UTF8ArrayToString(tty.output, 0));
|
|
tty.output = [];
|
|
}
|
|
}}};
|
|
Module["TTY"] = TTY;
|
|
|
|
var MEMFS={ops_table:null,mount:function(mount) {
|
|
return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
|
|
},createNode:function(parent, name, mode, dev) {
|
|
if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
|
|
// no supported
|
|
throw new FS.ErrnoError(63);
|
|
}
|
|
if (!MEMFS.ops_table) {
|
|
MEMFS.ops_table = {
|
|
dir: {
|
|
node: {
|
|
getattr: MEMFS.node_ops.getattr,
|
|
setattr: MEMFS.node_ops.setattr,
|
|
lookup: MEMFS.node_ops.lookup,
|
|
mknod: MEMFS.node_ops.mknod,
|
|
rename: MEMFS.node_ops.rename,
|
|
unlink: MEMFS.node_ops.unlink,
|
|
rmdir: MEMFS.node_ops.rmdir,
|
|
readdir: MEMFS.node_ops.readdir,
|
|
symlink: MEMFS.node_ops.symlink
|
|
},
|
|
stream: {
|
|
llseek: MEMFS.stream_ops.llseek
|
|
}
|
|
},
|
|
file: {
|
|
node: {
|
|
getattr: MEMFS.node_ops.getattr,
|
|
setattr: MEMFS.node_ops.setattr
|
|
},
|
|
stream: {
|
|
llseek: MEMFS.stream_ops.llseek,
|
|
read: MEMFS.stream_ops.read,
|
|
write: MEMFS.stream_ops.write,
|
|
allocate: MEMFS.stream_ops.allocate,
|
|
mmap: MEMFS.stream_ops.mmap,
|
|
msync: MEMFS.stream_ops.msync
|
|
}
|
|
},
|
|
link: {
|
|
node: {
|
|
getattr: MEMFS.node_ops.getattr,
|
|
setattr: MEMFS.node_ops.setattr,
|
|
readlink: MEMFS.node_ops.readlink
|
|
},
|
|
stream: {}
|
|
},
|
|
chrdev: {
|
|
node: {
|
|
getattr: MEMFS.node_ops.getattr,
|
|
setattr: MEMFS.node_ops.setattr
|
|
},
|
|
stream: FS.chrdev_stream_ops
|
|
}
|
|
};
|
|
}
|
|
var node = FS.createNode(parent, name, mode, dev);
|
|
if (FS.isDir(node.mode)) {
|
|
node.node_ops = MEMFS.ops_table.dir.node;
|
|
node.stream_ops = MEMFS.ops_table.dir.stream;
|
|
node.contents = {};
|
|
} else if (FS.isFile(node.mode)) {
|
|
node.node_ops = MEMFS.ops_table.file.node;
|
|
node.stream_ops = MEMFS.ops_table.file.stream;
|
|
node.usedBytes = 0; // The actual number of bytes used in the typed array, as opposed to contents.length which gives the whole capacity.
|
|
// When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred
|
|
// for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size
|
|
// penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme.
|
|
node.contents = null;
|
|
} else if (FS.isLink(node.mode)) {
|
|
node.node_ops = MEMFS.ops_table.link.node;
|
|
node.stream_ops = MEMFS.ops_table.link.stream;
|
|
} else if (FS.isChrdev(node.mode)) {
|
|
node.node_ops = MEMFS.ops_table.chrdev.node;
|
|
node.stream_ops = MEMFS.ops_table.chrdev.stream;
|
|
}
|
|
node.timestamp = Date.now();
|
|
// add the new node to the parent
|
|
if (parent) {
|
|
parent.contents[name] = node;
|
|
}
|
|
return node;
|
|
},getFileDataAsRegularArray:function(node) {
|
|
if (node.contents && node.contents.subarray) {
|
|
var arr = [];
|
|
for (var i = 0; i < node.usedBytes; ++i) arr.push(node.contents[i]);
|
|
return arr; // Returns a copy of the original data.
|
|
}
|
|
return node.contents; // No-op, the file contents are already in a JS array. Return as-is.
|
|
},getFileDataAsTypedArray:function(node) {
|
|
if (!node.contents) return new Uint8Array;
|
|
if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); // Make sure to not return excess unused bytes.
|
|
return new Uint8Array(node.contents);
|
|
},expandFileStorage:function(node, newCapacity) {
|
|
var prevCapacity = node.contents ? node.contents.length : 0;
|
|
if (prevCapacity >= newCapacity) return; // No need to expand, the storage was already large enough.
|
|
// Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity.
|
|
// For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to
|
|
// avoid overshooting the allocation cap by a very large margin.
|
|
var CAPACITY_DOUBLING_MAX = 1024 * 1024;
|
|
newCapacity = Math.max(newCapacity, (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2.0 : 1.125)) | 0);
|
|
if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); // At minimum allocate 256b for each file when expanding.
|
|
var oldContents = node.contents;
|
|
node.contents = new Uint8Array(newCapacity); // Allocate new storage.
|
|
if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); // Copy old data over to the new storage.
|
|
return;
|
|
},resizeFileStorage:function(node, newSize) {
|
|
if (node.usedBytes == newSize) return;
|
|
if (newSize == 0) {
|
|
node.contents = null; // Fully decommit when requesting a resize to zero.
|
|
node.usedBytes = 0;
|
|
return;
|
|
}
|
|
if (!node.contents || node.contents.subarray) { // Resize a typed array if that is being used as the backing store.
|
|
var oldContents = node.contents;
|
|
node.contents = new Uint8Array(new ArrayBuffer(newSize)); // Allocate new storage.
|
|
if (oldContents) {
|
|
node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); // Copy old data over to the new storage.
|
|
}
|
|
node.usedBytes = newSize;
|
|
return;
|
|
}
|
|
// Backing with a JS array.
|
|
if (!node.contents) node.contents = [];
|
|
if (node.contents.length > newSize) node.contents.length = newSize;
|
|
else while (node.contents.length < newSize) node.contents.push(0);
|
|
node.usedBytes = newSize;
|
|
},node_ops:{getattr:function(node) {
|
|
var attr = {};
|
|
// device numbers reuse inode numbers.
|
|
attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
|
|
attr.ino = node.id;
|
|
attr.mode = node.mode;
|
|
attr.nlink = 1;
|
|
attr.uid = 0;
|
|
attr.gid = 0;
|
|
attr.rdev = node.rdev;
|
|
if (FS.isDir(node.mode)) {
|
|
attr.size = 4096;
|
|
} else if (FS.isFile(node.mode)) {
|
|
attr.size = node.usedBytes;
|
|
} else if (FS.isLink(node.mode)) {
|
|
attr.size = node.link.length;
|
|
} else {
|
|
attr.size = 0;
|
|
}
|
|
attr.atime = new Date(node.timestamp);
|
|
attr.mtime = new Date(node.timestamp);
|
|
attr.ctime = new Date(node.timestamp);
|
|
// NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
|
|
// but this is not required by the standard.
|
|
attr.blksize = 4096;
|
|
attr.blocks = Math.ceil(attr.size / attr.blksize);
|
|
return attr;
|
|
},setattr:function(node, attr) {
|
|
if (attr.mode !== undefined) {
|
|
node.mode = attr.mode;
|
|
}
|
|
if (attr.timestamp !== undefined) {
|
|
node.timestamp = attr.timestamp;
|
|
}
|
|
if (attr.size !== undefined) {
|
|
MEMFS.resizeFileStorage(node, attr.size);
|
|
}
|
|
},lookup:function(parent, name) {
|
|
throw FS.genericErrors[44];
|
|
},mknod:function(parent, name, mode, dev) {
|
|
return MEMFS.createNode(parent, name, mode, dev);
|
|
},rename:function(old_node, new_dir, new_name) {
|
|
// if we're overwriting a directory at new_name, make sure it's empty.
|
|
if (FS.isDir(old_node.mode)) {
|
|
var new_node;
|
|
try {
|
|
new_node = FS.lookupNode(new_dir, new_name);
|
|
} catch (e) {
|
|
}
|
|
if (new_node) {
|
|
for (var i in new_node.contents) {
|
|
throw new FS.ErrnoError(55);
|
|
}
|
|
}
|
|
}
|
|
// do the internal rewiring
|
|
delete old_node.parent.contents[old_node.name];
|
|
old_node.name = new_name;
|
|
new_dir.contents[new_name] = old_node;
|
|
old_node.parent = new_dir;
|
|
},unlink:function(parent, name) {
|
|
delete parent.contents[name];
|
|
},rmdir:function(parent, name) {
|
|
var node = FS.lookupNode(parent, name);
|
|
for (var i in node.contents) {
|
|
throw new FS.ErrnoError(55);
|
|
}
|
|
delete parent.contents[name];
|
|
},readdir:function(node) {
|
|
var entries = ['.', '..'];
|
|
for (var key in node.contents) {
|
|
if (!node.contents.hasOwnProperty(key)) {
|
|
continue;
|
|
}
|
|
entries.push(key);
|
|
}
|
|
return entries;
|
|
},symlink:function(parent, newname, oldpath) {
|
|
var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
|
|
node.link = oldpath;
|
|
return node;
|
|
},readlink:function(node) {
|
|
if (!FS.isLink(node.mode)) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
return node.link;
|
|
}},stream_ops:{read:function(stream, buffer, offset, length, position) {
|
|
var contents = stream.node.contents;
|
|
if (position >= stream.node.usedBytes) return 0;
|
|
var size = Math.min(stream.node.usedBytes - position, length);
|
|
if (size > 8 && contents.subarray) { // non-trivial, and typed array
|
|
buffer.set(contents.subarray(position, position + size), offset);
|
|
} else {
|
|
for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i];
|
|
}
|
|
return size;
|
|
},write:function(stream, buffer, offset, length, position, canOwn) {
|
|
|
|
if (!length) return 0;
|
|
var node = stream.node;
|
|
node.timestamp = Date.now();
|
|
|
|
if (buffer.subarray && (!node.contents || node.contents.subarray)) { // This write is from a typed array to a typed array?
|
|
if (canOwn) {
|
|
node.contents = buffer.subarray(offset, offset + length);
|
|
node.usedBytes = length;
|
|
return length;
|
|
} else if (node.usedBytes === 0 && position === 0) { // If this is a simple first write to an empty file, do a fast set since we don't need to care about old data.
|
|
node.contents = new Uint8Array(buffer.subarray(offset, offset + length));
|
|
node.usedBytes = length;
|
|
return length;
|
|
} else if (position + length <= node.usedBytes) { // Writing to an already allocated and used subrange of the file?
|
|
node.contents.set(buffer.subarray(offset, offset + length), position);
|
|
return length;
|
|
}
|
|
}
|
|
|
|
// Appending to an existing file and we need to reallocate, or source data did not come as a typed array.
|
|
MEMFS.expandFileStorage(node, position+length);
|
|
if (node.contents.subarray && buffer.subarray) node.contents.set(buffer.subarray(offset, offset + length), position); // Use typed array write if available.
|
|
else {
|
|
for (var i = 0; i < length; i++) {
|
|
node.contents[position + i] = buffer[offset + i]; // Or fall back to manual write if not.
|
|
}
|
|
}
|
|
node.usedBytes = Math.max(node.usedBytes, position+length);
|
|
return length;
|
|
},llseek:function(stream, offset, whence) {
|
|
var position = offset;
|
|
if (whence === 1) {
|
|
position += stream.position;
|
|
} else if (whence === 2) {
|
|
if (FS.isFile(stream.node.mode)) {
|
|
position += stream.node.usedBytes;
|
|
}
|
|
}
|
|
if (position < 0) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
return position;
|
|
},allocate:function(stream, offset, length) {
|
|
MEMFS.expandFileStorage(stream.node, offset + length);
|
|
stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
|
|
},mmap:function(stream, buffer, offset, length, position, prot, flags) {
|
|
if (!FS.isFile(stream.node.mode)) {
|
|
throw new FS.ErrnoError(43);
|
|
}
|
|
var ptr;
|
|
var allocated;
|
|
var contents = stream.node.contents;
|
|
// Only make a new copy when MAP_PRIVATE is specified.
|
|
if ( !(flags & 2) &&
|
|
contents.buffer === buffer.buffer ) {
|
|
// We can't emulate MAP_SHARED when the file is not backed by the buffer
|
|
// we're mapping to (e.g. the HEAP buffer).
|
|
allocated = false;
|
|
ptr = contents.byteOffset;
|
|
} else {
|
|
// Try to avoid unnecessary slices.
|
|
if (position > 0 || position + length < stream.node.usedBytes) {
|
|
if (contents.subarray) {
|
|
contents = contents.subarray(position, position + length);
|
|
} else {
|
|
contents = Array.prototype.slice.call(contents, position, position + length);
|
|
}
|
|
}
|
|
allocated = true;
|
|
// malloc() can lead to growing the heap. If targeting the heap, we need to
|
|
// re-acquire the heap buffer object in case growth had occurred.
|
|
var fromHeap = (buffer.buffer == HEAP8.buffer);
|
|
ptr = _malloc(length);
|
|
if (!ptr) {
|
|
throw new FS.ErrnoError(48);
|
|
}
|
|
(fromHeap ? HEAP8 : buffer).set(contents, ptr);
|
|
}
|
|
return { ptr: ptr, allocated: allocated };
|
|
},msync:function(stream, buffer, offset, length, mmapFlags) {
|
|
if (!FS.isFile(stream.node.mode)) {
|
|
throw new FS.ErrnoError(43);
|
|
}
|
|
if (mmapFlags & 2) {
|
|
// MAP_PRIVATE calls need not to be synced back to underlying fs
|
|
return 0;
|
|
}
|
|
|
|
var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
|
|
// should we check if bytesWritten and length are the same?
|
|
return 0;
|
|
}}};
|
|
Module["MEMFS"] = MEMFS;
|
|
|
|
var NODEFS={isWindows:false,staticInit:function() {
|
|
NODEFS.isWindows = !!process.platform.match(/^win/);
|
|
var flags = process["binding"]("constants");
|
|
// Node.js 4 compatibility: it has no namespaces for constants
|
|
if (flags["fs"]) {
|
|
flags = flags["fs"];
|
|
}
|
|
NODEFS.flagsForNodeMap = {
|
|
"1024": flags["O_APPEND"],
|
|
"64": flags["O_CREAT"],
|
|
"128": flags["O_EXCL"],
|
|
"0": flags["O_RDONLY"],
|
|
"2": flags["O_RDWR"],
|
|
"4096": flags["O_SYNC"],
|
|
"512": flags["O_TRUNC"],
|
|
"1": flags["O_WRONLY"]
|
|
};
|
|
},bufferFrom:function (arrayBuffer) {
|
|
// Node.js < 4.5 compatibility: Buffer.from does not support ArrayBuffer
|
|
// Buffer.from before 4.5 was just a method inherited from Uint8Array
|
|
// Buffer.alloc has been added with Buffer.from together, so check it instead
|
|
return Buffer["alloc"] ? Buffer.from(arrayBuffer) : new Buffer(arrayBuffer);
|
|
},convertNodeCode:function(e) {
|
|
var code = e.code;
|
|
assert(code in ERRNO_CODES);
|
|
return ERRNO_CODES[code];
|
|
},mount:function (mount) {
|
|
assert(ENVIRONMENT_HAS_NODE);
|
|
return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
|
|
},createNode:function (parent, name, mode, dev) {
|
|
if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
var node = FS.createNode(parent, name, mode);
|
|
node.node_ops = NODEFS.node_ops;
|
|
node.stream_ops = NODEFS.stream_ops;
|
|
return node;
|
|
},getMode:function (path) {
|
|
var stat;
|
|
try {
|
|
stat = fs.lstatSync(path);
|
|
if (NODEFS.isWindows) {
|
|
// Node.js on Windows never represents permission bit 'x', so
|
|
// propagate read bits to execute bits
|
|
stat.mode = stat.mode | ((stat.mode & 292) >> 2);
|
|
}
|
|
} catch (e) {
|
|
if (!e.code) throw e;
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
return stat.mode;
|
|
},realPath:function (node) {
|
|
var parts = [];
|
|
while (node.parent !== node) {
|
|
parts.push(node.name);
|
|
node = node.parent;
|
|
}
|
|
parts.push(node.mount.opts.root);
|
|
parts.reverse();
|
|
return PATH.join.apply(null, parts);
|
|
},flagsForNode:function(flags) {
|
|
flags &= ~0x200000 /*O_PATH*/; // Ignore this flag from musl, otherwise node.js fails to open the file.
|
|
flags &= ~0x800 /*O_NONBLOCK*/; // Ignore this flag from musl, otherwise node.js fails to open the file.
|
|
flags &= ~0x8000 /*O_LARGEFILE*/; // Ignore this flag from musl, otherwise node.js fails to open the file.
|
|
flags &= ~0x80000 /*O_CLOEXEC*/; // Some applications may pass it; it makes no sense for a single process.
|
|
var newFlags = 0;
|
|
for (var k in NODEFS.flagsForNodeMap) {
|
|
if (flags & k) {
|
|
newFlags |= NODEFS.flagsForNodeMap[k];
|
|
flags ^= k;
|
|
}
|
|
}
|
|
|
|
if (!flags) {
|
|
return newFlags;
|
|
} else {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
},node_ops:{getattr:function(node) {
|
|
var path = NODEFS.realPath(node);
|
|
var stat;
|
|
try {
|
|
stat = fs.lstatSync(path);
|
|
} catch (e) {
|
|
if (!e.code) throw e;
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
// node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
|
|
// See http://support.microsoft.com/kb/140365
|
|
if (NODEFS.isWindows && !stat.blksize) {
|
|
stat.blksize = 4096;
|
|
}
|
|
if (NODEFS.isWindows && !stat.blocks) {
|
|
stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
|
|
}
|
|
return {
|
|
dev: stat.dev,
|
|
ino: stat.ino,
|
|
mode: stat.mode,
|
|
nlink: stat.nlink,
|
|
uid: stat.uid,
|
|
gid: stat.gid,
|
|
rdev: stat.rdev,
|
|
size: stat.size,
|
|
atime: stat.atime,
|
|
mtime: stat.mtime,
|
|
ctime: stat.ctime,
|
|
blksize: stat.blksize,
|
|
blocks: stat.blocks
|
|
};
|
|
},setattr:function(node, attr) {
|
|
var path = NODEFS.realPath(node);
|
|
try {
|
|
if (attr.mode !== undefined) {
|
|
fs.chmodSync(path, attr.mode);
|
|
// update the common node structure mode as well
|
|
node.mode = attr.mode;
|
|
}
|
|
if (attr.timestamp !== undefined) {
|
|
var date = new Date(attr.timestamp);
|
|
fs.utimesSync(path, date, date);
|
|
}
|
|
if (attr.size !== undefined) {
|
|
fs.truncateSync(path, attr.size);
|
|
}
|
|
} catch (e) {
|
|
if (!e.code) throw e;
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
},lookup:function (parent, name) {
|
|
var path = PATH.join2(NODEFS.realPath(parent), name);
|
|
var mode = NODEFS.getMode(path);
|
|
return NODEFS.createNode(parent, name, mode);
|
|
},mknod:function (parent, name, mode, dev) {
|
|
var node = NODEFS.createNode(parent, name, mode, dev);
|
|
// create the backing node for this in the fs root as well
|
|
var path = NODEFS.realPath(node);
|
|
try {
|
|
if (FS.isDir(node.mode)) {
|
|
fs.mkdirSync(path, node.mode);
|
|
} else {
|
|
fs.writeFileSync(path, '', { mode: node.mode });
|
|
}
|
|
} catch (e) {
|
|
if (!e.code) throw e;
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
return node;
|
|
},rename:function (oldNode, newDir, newName) {
|
|
var oldPath = NODEFS.realPath(oldNode);
|
|
var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
|
|
try {
|
|
fs.renameSync(oldPath, newPath);
|
|
} catch (e) {
|
|
if (!e.code) throw e;
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
},unlink:function(parent, name) {
|
|
var path = PATH.join2(NODEFS.realPath(parent), name);
|
|
try {
|
|
fs.unlinkSync(path);
|
|
} catch (e) {
|
|
if (!e.code) throw e;
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
},rmdir:function(parent, name) {
|
|
var path = PATH.join2(NODEFS.realPath(parent), name);
|
|
try {
|
|
fs.rmdirSync(path);
|
|
} catch (e) {
|
|
if (!e.code) throw e;
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
},readdir:function(node) {
|
|
var path = NODEFS.realPath(node);
|
|
try {
|
|
return fs.readdirSync(path);
|
|
} catch (e) {
|
|
if (!e.code) throw e;
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
},symlink:function(parent, newName, oldPath) {
|
|
var newPath = PATH.join2(NODEFS.realPath(parent), newName);
|
|
try {
|
|
fs.symlinkSync(oldPath, newPath);
|
|
} catch (e) {
|
|
if (!e.code) throw e;
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
},readlink:function(node) {
|
|
var path = NODEFS.realPath(node);
|
|
try {
|
|
path = fs.readlinkSync(path);
|
|
path = NODEJS_PATH.relative(NODEJS_PATH.resolve(node.mount.opts.root), path);
|
|
return path;
|
|
} catch (e) {
|
|
if (!e.code) throw e;
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
}},stream_ops:{open:function (stream) {
|
|
var path = NODEFS.realPath(stream.node);
|
|
try {
|
|
if (FS.isFile(stream.node.mode)) {
|
|
stream.nfd = fs.openSync(path, NODEFS.flagsForNode(stream.flags));
|
|
}
|
|
} catch (e) {
|
|
if (!e.code) throw e;
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
},close:function (stream) {
|
|
try {
|
|
if (FS.isFile(stream.node.mode) && stream.nfd) {
|
|
fs.closeSync(stream.nfd);
|
|
}
|
|
} catch (e) {
|
|
if (!e.code) throw e;
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
},read:function (stream, buffer, offset, length, position) {
|
|
// Node.js < 6 compatibility: node errors on 0 length reads
|
|
if (length === 0) return 0;
|
|
try {
|
|
return fs.readSync(stream.nfd, NODEFS.bufferFrom(buffer.buffer), offset, length, position);
|
|
} catch (e) {
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
},write:function (stream, buffer, offset, length, position) {
|
|
try {
|
|
return fs.writeSync(stream.nfd, NODEFS.bufferFrom(buffer.buffer), offset, length, position);
|
|
} catch (e) {
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
},llseek:function (stream, offset, whence) {
|
|
var position = offset;
|
|
if (whence === 1) {
|
|
position += stream.position;
|
|
} else if (whence === 2) {
|
|
if (FS.isFile(stream.node.mode)) {
|
|
try {
|
|
var stat = fs.fstatSync(stream.nfd);
|
|
position += stat.size;
|
|
} catch (e) {
|
|
throw new FS.ErrnoError(NODEFS.convertNodeCode(e));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (position < 0) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
|
|
return position;
|
|
}}};
|
|
Module["NODEFS"] = NODEFS;var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,trackingDelegate:{},tracking:{openFlags:{READ:1,WRITE:2}},ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,handleFSError:function(e) {
|
|
if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
|
|
return ___setErrNo(e.errno);
|
|
},lookupPath:function(path, opts) {
|
|
path = PATH_FS.resolve(FS.cwd(), path);
|
|
opts = opts || {};
|
|
|
|
if (!path) return { path: '', node: null };
|
|
|
|
var defaults = {
|
|
follow_mount: true,
|
|
recurse_count: 0
|
|
};
|
|
for (var key in defaults) {
|
|
if (opts[key] === undefined) {
|
|
opts[key] = defaults[key];
|
|
}
|
|
}
|
|
|
|
if (opts.recurse_count > 8) { // max recursive lookup of 8
|
|
throw new FS.ErrnoError(32);
|
|
}
|
|
|
|
// split the path
|
|
var parts = PATH.normalizeArray(path.split('/').filter(function(p) {
|
|
return !!p;
|
|
}), false);
|
|
|
|
// start at the root
|
|
var current = FS.root;
|
|
var current_path = '/';
|
|
|
|
for (var i = 0; i < parts.length; i++) {
|
|
var islast = (i === parts.length-1);
|
|
if (islast && opts.parent) {
|
|
// stop resolving
|
|
break;
|
|
}
|
|
|
|
current = FS.lookupNode(current, parts[i]);
|
|
current_path = PATH.join2(current_path, parts[i]);
|
|
|
|
// jump to the mount's root node if this is a mountpoint
|
|
if (FS.isMountpoint(current)) {
|
|
if (!islast || (islast && opts.follow_mount)) {
|
|
current = current.mounted.root;
|
|
}
|
|
}
|
|
|
|
// by default, lookupPath will not follow a symlink if it is the final path component.
|
|
// setting opts.follow = true will override this behavior.
|
|
if (!islast || opts.follow) {
|
|
var count = 0;
|
|
while (FS.isLink(current.mode)) {
|
|
var link = FS.readlink(current_path);
|
|
current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
|
|
|
|
var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
|
|
current = lookup.node;
|
|
|
|
if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
|
|
throw new FS.ErrnoError(32);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return { path: current_path, node: current };
|
|
},getPath:function(node) {
|
|
var path;
|
|
while (true) {
|
|
if (FS.isRoot(node)) {
|
|
var mount = node.mount.mountpoint;
|
|
if (!path) return mount;
|
|
return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
|
|
}
|
|
path = path ? node.name + '/' + path : node.name;
|
|
node = node.parent;
|
|
}
|
|
},hashName:function(parentid, name) {
|
|
var hash = 0;
|
|
|
|
|
|
for (var i = 0; i < name.length; i++) {
|
|
hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
|
|
}
|
|
return ((parentid + hash) >>> 0) % FS.nameTable.length;
|
|
},hashAddNode:function(node) {
|
|
var hash = FS.hashName(node.parent.id, node.name);
|
|
node.name_next = FS.nameTable[hash];
|
|
FS.nameTable[hash] = node;
|
|
},hashRemoveNode:function(node) {
|
|
var hash = FS.hashName(node.parent.id, node.name);
|
|
if (FS.nameTable[hash] === node) {
|
|
FS.nameTable[hash] = node.name_next;
|
|
} else {
|
|
var current = FS.nameTable[hash];
|
|
while (current) {
|
|
if (current.name_next === node) {
|
|
current.name_next = node.name_next;
|
|
break;
|
|
}
|
|
current = current.name_next;
|
|
}
|
|
}
|
|
},lookupNode:function(parent, name) {
|
|
var err = FS.mayLookup(parent);
|
|
if (err) {
|
|
throw new FS.ErrnoError(err, parent);
|
|
}
|
|
var hash = FS.hashName(parent.id, name);
|
|
for (var node = FS.nameTable[hash]; node; node = node.name_next) {
|
|
var nodeName = node.name;
|
|
if (node.parent.id === parent.id && nodeName === name) {
|
|
return node;
|
|
}
|
|
}
|
|
// if we failed to find it in the cache, call into the VFS
|
|
return FS.lookup(parent, name);
|
|
},createNode:function(parent, name, mode, rdev) {
|
|
if (!FS.FSNode) {
|
|
FS.FSNode = function(parent, name, mode, rdev) {
|
|
if (!parent) {
|
|
parent = this; // root node sets parent to itself
|
|
}
|
|
this.parent = parent;
|
|
this.mount = parent.mount;
|
|
this.mounted = null;
|
|
this.id = FS.nextInode++;
|
|
this.name = name;
|
|
this.mode = mode;
|
|
this.node_ops = {};
|
|
this.stream_ops = {};
|
|
this.rdev = rdev;
|
|
};
|
|
|
|
FS.FSNode.prototype = {};
|
|
|
|
// compatibility
|
|
var readMode = 292 | 73;
|
|
var writeMode = 146;
|
|
|
|
// NOTE we must use Object.defineProperties instead of individual calls to
|
|
// Object.defineProperty in order to make closure compiler happy
|
|
Object.defineProperties(FS.FSNode.prototype, {
|
|
read: {
|
|
get: function() { return (this.mode & readMode) === readMode; },
|
|
set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
|
|
},
|
|
write: {
|
|
get: function() { return (this.mode & writeMode) === writeMode; },
|
|
set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
|
|
},
|
|
isFolder: {
|
|
get: function() { return FS.isDir(this.mode); }
|
|
},
|
|
isDevice: {
|
|
get: function() { return FS.isChrdev(this.mode); }
|
|
}
|
|
});
|
|
}
|
|
|
|
var node = new FS.FSNode(parent, name, mode, rdev);
|
|
|
|
FS.hashAddNode(node);
|
|
|
|
return node;
|
|
},destroyNode:function(node) {
|
|
FS.hashRemoveNode(node);
|
|
},isRoot:function(node) {
|
|
return node === node.parent;
|
|
},isMountpoint:function(node) {
|
|
return !!node.mounted;
|
|
},isFile:function(mode) {
|
|
return (mode & 61440) === 32768;
|
|
},isDir:function(mode) {
|
|
return (mode & 61440) === 16384;
|
|
},isLink:function(mode) {
|
|
return (mode & 61440) === 40960;
|
|
},isChrdev:function(mode) {
|
|
return (mode & 61440) === 8192;
|
|
},isBlkdev:function(mode) {
|
|
return (mode & 61440) === 24576;
|
|
},isFIFO:function(mode) {
|
|
return (mode & 61440) === 4096;
|
|
},isSocket:function(mode) {
|
|
return (mode & 49152) === 49152;
|
|
},flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function(str) {
|
|
var flags = FS.flagModes[str];
|
|
if (typeof flags === 'undefined') {
|
|
throw new Error('Unknown file open mode: ' + str);
|
|
}
|
|
return flags;
|
|
},flagsToPermissionString:function(flag) {
|
|
var perms = ['r', 'w', 'rw'][flag & 3];
|
|
if ((flag & 512)) {
|
|
perms += 'w';
|
|
}
|
|
return perms;
|
|
},nodePermissions:function(node, perms) {
|
|
if (FS.ignorePermissions) {
|
|
return 0;
|
|
}
|
|
// return 0 if any user, group or owner bits are set.
|
|
if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
|
|
return 2;
|
|
} else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
|
|
return 2;
|
|
} else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
|
|
return 2;
|
|
}
|
|
return 0;
|
|
},mayLookup:function(dir) {
|
|
var err = FS.nodePermissions(dir, 'x');
|
|
if (err) return err;
|
|
if (!dir.node_ops.lookup) return 2;
|
|
return 0;
|
|
},mayCreate:function(dir, name) {
|
|
try {
|
|
var node = FS.lookupNode(dir, name);
|
|
return 20;
|
|
} catch (e) {
|
|
}
|
|
return FS.nodePermissions(dir, 'wx');
|
|
},mayDelete:function(dir, name, isdir) {
|
|
var node;
|
|
try {
|
|
node = FS.lookupNode(dir, name);
|
|
} catch (e) {
|
|
return e.errno;
|
|
}
|
|
var err = FS.nodePermissions(dir, 'wx');
|
|
if (err) {
|
|
return err;
|
|
}
|
|
if (isdir) {
|
|
if (!FS.isDir(node.mode)) {
|
|
return 54;
|
|
}
|
|
if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
|
|
return 10;
|
|
}
|
|
} else {
|
|
if (FS.isDir(node.mode)) {
|
|
return 31;
|
|
}
|
|
}
|
|
return 0;
|
|
},mayOpen:function(node, flags) {
|
|
if (!node) {
|
|
return 44;
|
|
}
|
|
if (FS.isLink(node.mode)) {
|
|
return 32;
|
|
} else if (FS.isDir(node.mode)) {
|
|
if (FS.flagsToPermissionString(flags) !== 'r' || // opening for write
|
|
(flags & 512)) { // TODO: check for O_SEARCH? (== search for dir only)
|
|
return 31;
|
|
}
|
|
}
|
|
return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
|
|
},MAX_OPEN_FDS:4096,nextfd:function(fd_start, fd_end) {
|
|
fd_start = fd_start || 0;
|
|
fd_end = fd_end || FS.MAX_OPEN_FDS;
|
|
for (var fd = fd_start; fd <= fd_end; fd++) {
|
|
if (!FS.streams[fd]) {
|
|
return fd;
|
|
}
|
|
}
|
|
throw new FS.ErrnoError(33);
|
|
},getStream:function(fd) {
|
|
return FS.streams[fd];
|
|
},createStream:function(stream, fd_start, fd_end) {
|
|
if (!FS.FSStream) {
|
|
FS.FSStream = function(){};
|
|
FS.FSStream.prototype = {};
|
|
// compatibility
|
|
Object.defineProperties(FS.FSStream.prototype, {
|
|
object: {
|
|
get: function() { return this.node; },
|
|
set: function(val) { this.node = val; }
|
|
},
|
|
isRead: {
|
|
get: function() { return (this.flags & 2097155) !== 1; }
|
|
},
|
|
isWrite: {
|
|
get: function() { return (this.flags & 2097155) !== 0; }
|
|
},
|
|
isAppend: {
|
|
get: function() { return (this.flags & 1024); }
|
|
}
|
|
});
|
|
}
|
|
// clone it, so we can return an instance of FSStream
|
|
var newStream = new FS.FSStream();
|
|
for (var p in stream) {
|
|
newStream[p] = stream[p];
|
|
}
|
|
stream = newStream;
|
|
var fd = FS.nextfd(fd_start, fd_end);
|
|
stream.fd = fd;
|
|
FS.streams[fd] = stream;
|
|
return stream;
|
|
},closeStream:function(fd) {
|
|
FS.streams[fd] = null;
|
|
},chrdev_stream_ops:{open:function(stream) {
|
|
var device = FS.getDevice(stream.node.rdev);
|
|
// override node's stream ops with the device's
|
|
stream.stream_ops = device.stream_ops;
|
|
// forward the open call
|
|
if (stream.stream_ops.open) {
|
|
stream.stream_ops.open(stream);
|
|
}
|
|
},llseek:function() {
|
|
throw new FS.ErrnoError(70);
|
|
}},major:function(dev) {
|
|
return ((dev) >> 8);
|
|
},minor:function(dev) {
|
|
return ((dev) & 0xff);
|
|
},makedev:function(ma, mi) {
|
|
return ((ma) << 8 | (mi));
|
|
},registerDevice:function(dev, ops) {
|
|
FS.devices[dev] = { stream_ops: ops };
|
|
},getDevice:function(dev) {
|
|
return FS.devices[dev];
|
|
},getMounts:function(mount) {
|
|
var mounts = [];
|
|
var check = [mount];
|
|
|
|
while (check.length) {
|
|
var m = check.pop();
|
|
|
|
mounts.push(m);
|
|
|
|
check.push.apply(check, m.mounts);
|
|
}
|
|
|
|
return mounts;
|
|
},syncfs:function(populate, callback) {
|
|
if (typeof(populate) === 'function') {
|
|
callback = populate;
|
|
populate = false;
|
|
}
|
|
|
|
FS.syncFSRequests++;
|
|
|
|
if (FS.syncFSRequests > 1) {
|
|
console.log('warning: ' + FS.syncFSRequests + ' FS.syncfs operations in flight at once, probably just doing extra work');
|
|
}
|
|
|
|
var mounts = FS.getMounts(FS.root.mount);
|
|
var completed = 0;
|
|
|
|
function doCallback(err) {
|
|
FS.syncFSRequests--;
|
|
return callback(err);
|
|
}
|
|
|
|
function done(err) {
|
|
if (err) {
|
|
if (!done.errored) {
|
|
done.errored = true;
|
|
return doCallback(err);
|
|
}
|
|
return;
|
|
}
|
|
if (++completed >= mounts.length) {
|
|
doCallback(null);
|
|
}
|
|
};
|
|
|
|
// sync all mounts
|
|
mounts.forEach(function (mount) {
|
|
if (!mount.type.syncfs) {
|
|
return done(null);
|
|
}
|
|
mount.type.syncfs(mount, populate, done);
|
|
});
|
|
},mount:function(type, opts, mountpoint) {
|
|
var root = mountpoint === '/';
|
|
var pseudo = !mountpoint;
|
|
var node;
|
|
|
|
if (root && FS.root) {
|
|
throw new FS.ErrnoError(10);
|
|
} else if (!root && !pseudo) {
|
|
var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
|
|
|
|
mountpoint = lookup.path; // use the absolute path
|
|
node = lookup.node;
|
|
|
|
if (FS.isMountpoint(node)) {
|
|
throw new FS.ErrnoError(10);
|
|
}
|
|
|
|
if (!FS.isDir(node.mode)) {
|
|
throw new FS.ErrnoError(54);
|
|
}
|
|
}
|
|
|
|
var mount = {
|
|
type: type,
|
|
opts: opts,
|
|
mountpoint: mountpoint,
|
|
mounts: []
|
|
};
|
|
|
|
// create a root node for the fs
|
|
var mountRoot = type.mount(mount);
|
|
mountRoot.mount = mount;
|
|
mount.root = mountRoot;
|
|
|
|
if (root) {
|
|
FS.root = mountRoot;
|
|
} else if (node) {
|
|
// set as a mountpoint
|
|
node.mounted = mount;
|
|
|
|
// add the new mount to the current mount's children
|
|
if (node.mount) {
|
|
node.mount.mounts.push(mount);
|
|
}
|
|
}
|
|
|
|
return mountRoot;
|
|
},unmount:function (mountpoint) {
|
|
var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
|
|
|
|
if (!FS.isMountpoint(lookup.node)) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
|
|
// destroy the nodes for this mount, and all its child mounts
|
|
var node = lookup.node;
|
|
var mount = node.mounted;
|
|
var mounts = FS.getMounts(mount);
|
|
|
|
Object.keys(FS.nameTable).forEach(function (hash) {
|
|
var current = FS.nameTable[hash];
|
|
|
|
while (current) {
|
|
var next = current.name_next;
|
|
|
|
if (mounts.indexOf(current.mount) !== -1) {
|
|
FS.destroyNode(current);
|
|
}
|
|
|
|
current = next;
|
|
}
|
|
});
|
|
|
|
// no longer a mountpoint
|
|
node.mounted = null;
|
|
|
|
// remove this mount from the child mounts
|
|
var idx = node.mount.mounts.indexOf(mount);
|
|
node.mount.mounts.splice(idx, 1);
|
|
},lookup:function(parent, name) {
|
|
return parent.node_ops.lookup(parent, name);
|
|
},mknod:function(path, mode, dev) {
|
|
var lookup = FS.lookupPath(path, { parent: true });
|
|
var parent = lookup.node;
|
|
var name = PATH.basename(path);
|
|
if (!name || name === '.' || name === '..') {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
var err = FS.mayCreate(parent, name);
|
|
if (err) {
|
|
throw new FS.ErrnoError(err);
|
|
}
|
|
if (!parent.node_ops.mknod) {
|
|
throw new FS.ErrnoError(63);
|
|
}
|
|
return parent.node_ops.mknod(parent, name, mode, dev);
|
|
},create:function(path, mode) {
|
|
mode = mode !== undefined ? mode : 438 /* 0666 */;
|
|
mode &= 4095;
|
|
mode |= 32768;
|
|
return FS.mknod(path, mode, 0);
|
|
},mkdir:function(path, mode) {
|
|
mode = mode !== undefined ? mode : 511 /* 0777 */;
|
|
mode &= 511 | 512;
|
|
mode |= 16384;
|
|
return FS.mknod(path, mode, 0);
|
|
},mkdirTree:function(path, mode) {
|
|
var dirs = path.split('/');
|
|
var d = '';
|
|
for (var i = 0; i < dirs.length; ++i) {
|
|
if (!dirs[i]) continue;
|
|
d += '/' + dirs[i];
|
|
try {
|
|
FS.mkdir(d, mode);
|
|
} catch(e) {
|
|
if (e.errno != 20) throw e;
|
|
}
|
|
}
|
|
},mkdev:function(path, mode, dev) {
|
|
if (typeof(dev) === 'undefined') {
|
|
dev = mode;
|
|
mode = 438 /* 0666 */;
|
|
}
|
|
mode |= 8192;
|
|
return FS.mknod(path, mode, dev);
|
|
},symlink:function(oldpath, newpath) {
|
|
if (!PATH_FS.resolve(oldpath)) {
|
|
throw new FS.ErrnoError(44);
|
|
}
|
|
var lookup = FS.lookupPath(newpath, { parent: true });
|
|
var parent = lookup.node;
|
|
if (!parent) {
|
|
throw new FS.ErrnoError(44);
|
|
}
|
|
var newname = PATH.basename(newpath);
|
|
var err = FS.mayCreate(parent, newname);
|
|
if (err) {
|
|
throw new FS.ErrnoError(err);
|
|
}
|
|
if (!parent.node_ops.symlink) {
|
|
throw new FS.ErrnoError(63);
|
|
}
|
|
return parent.node_ops.symlink(parent, newname, oldpath);
|
|
},rename:function(old_path, new_path) {
|
|
var old_dirname = PATH.dirname(old_path);
|
|
var new_dirname = PATH.dirname(new_path);
|
|
var old_name = PATH.basename(old_path);
|
|
var new_name = PATH.basename(new_path);
|
|
// parents must exist
|
|
var lookup, old_dir, new_dir;
|
|
try {
|
|
lookup = FS.lookupPath(old_path, { parent: true });
|
|
old_dir = lookup.node;
|
|
lookup = FS.lookupPath(new_path, { parent: true });
|
|
new_dir = lookup.node;
|
|
} catch (e) {
|
|
throw new FS.ErrnoError(10);
|
|
}
|
|
if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
|
|
// need to be part of the same mount
|
|
if (old_dir.mount !== new_dir.mount) {
|
|
throw new FS.ErrnoError(75);
|
|
}
|
|
// source must exist
|
|
var old_node = FS.lookupNode(old_dir, old_name);
|
|
// old path should not be an ancestor of the new path
|
|
var relative = PATH_FS.relative(old_path, new_dirname);
|
|
if (relative.charAt(0) !== '.') {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
// new path should not be an ancestor of the old path
|
|
relative = PATH_FS.relative(new_path, old_dirname);
|
|
if (relative.charAt(0) !== '.') {
|
|
throw new FS.ErrnoError(55);
|
|
}
|
|
// see if the new path already exists
|
|
var new_node;
|
|
try {
|
|
new_node = FS.lookupNode(new_dir, new_name);
|
|
} catch (e) {
|
|
// not fatal
|
|
}
|
|
// early out if nothing needs to change
|
|
if (old_node === new_node) {
|
|
return;
|
|
}
|
|
// we'll need to delete the old entry
|
|
var isdir = FS.isDir(old_node.mode);
|
|
var err = FS.mayDelete(old_dir, old_name, isdir);
|
|
if (err) {
|
|
throw new FS.ErrnoError(err);
|
|
}
|
|
// need delete permissions if we'll be overwriting.
|
|
// need create permissions if new doesn't already exist.
|
|
err = new_node ?
|
|
FS.mayDelete(new_dir, new_name, isdir) :
|
|
FS.mayCreate(new_dir, new_name);
|
|
if (err) {
|
|
throw new FS.ErrnoError(err);
|
|
}
|
|
if (!old_dir.node_ops.rename) {
|
|
throw new FS.ErrnoError(63);
|
|
}
|
|
if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
|
|
throw new FS.ErrnoError(10);
|
|
}
|
|
// if we are going to change the parent, check write permissions
|
|
if (new_dir !== old_dir) {
|
|
err = FS.nodePermissions(old_dir, 'w');
|
|
if (err) {
|
|
throw new FS.ErrnoError(err);
|
|
}
|
|
}
|
|
try {
|
|
if (FS.trackingDelegate['willMovePath']) {
|
|
FS.trackingDelegate['willMovePath'](old_path, new_path);
|
|
}
|
|
} catch(e) {
|
|
console.log("FS.trackingDelegate['willMovePath']('"+old_path+"', '"+new_path+"') threw an exception: " + e.message);
|
|
}
|
|
// remove the node from the lookup hash
|
|
FS.hashRemoveNode(old_node);
|
|
// do the underlying fs rename
|
|
try {
|
|
old_dir.node_ops.rename(old_node, new_dir, new_name);
|
|
} catch (e) {
|
|
throw e;
|
|
} finally {
|
|
// add the node back to the hash (in case node_ops.rename
|
|
// changed its name)
|
|
FS.hashAddNode(old_node);
|
|
}
|
|
try {
|
|
if (FS.trackingDelegate['onMovePath']) FS.trackingDelegate['onMovePath'](old_path, new_path);
|
|
} catch(e) {
|
|
console.log("FS.trackingDelegate['onMovePath']('"+old_path+"', '"+new_path+"') threw an exception: " + e.message);
|
|
}
|
|
},rmdir:function(path) {
|
|
var lookup = FS.lookupPath(path, { parent: true });
|
|
var parent = lookup.node;
|
|
var name = PATH.basename(path);
|
|
var node = FS.lookupNode(parent, name);
|
|
var err = FS.mayDelete(parent, name, true);
|
|
if (err) {
|
|
throw new FS.ErrnoError(err);
|
|
}
|
|
if (!parent.node_ops.rmdir) {
|
|
throw new FS.ErrnoError(63);
|
|
}
|
|
if (FS.isMountpoint(node)) {
|
|
throw new FS.ErrnoError(10);
|
|
}
|
|
try {
|
|
if (FS.trackingDelegate['willDeletePath']) {
|
|
FS.trackingDelegate['willDeletePath'](path);
|
|
}
|
|
} catch(e) {
|
|
console.log("FS.trackingDelegate['willDeletePath']('"+path+"') threw an exception: " + e.message);
|
|
}
|
|
parent.node_ops.rmdir(parent, name);
|
|
FS.destroyNode(node);
|
|
try {
|
|
if (FS.trackingDelegate['onDeletePath']) FS.trackingDelegate['onDeletePath'](path);
|
|
} catch(e) {
|
|
console.log("FS.trackingDelegate['onDeletePath']('"+path+"') threw an exception: " + e.message);
|
|
}
|
|
},readdir:function(path) {
|
|
var lookup = FS.lookupPath(path, { follow: true });
|
|
var node = lookup.node;
|
|
if (!node.node_ops.readdir) {
|
|
throw new FS.ErrnoError(54);
|
|
}
|
|
return node.node_ops.readdir(node);
|
|
},unlink:function(path) {
|
|
var lookup = FS.lookupPath(path, { parent: true });
|
|
var parent = lookup.node;
|
|
var name = PATH.basename(path);
|
|
var node = FS.lookupNode(parent, name);
|
|
var err = FS.mayDelete(parent, name, false);
|
|
if (err) {
|
|
// According to POSIX, we should map EISDIR to EPERM, but
|
|
// we instead do what Linux does (and we must, as we use
|
|
// the musl linux libc).
|
|
throw new FS.ErrnoError(err);
|
|
}
|
|
if (!parent.node_ops.unlink) {
|
|
throw new FS.ErrnoError(63);
|
|
}
|
|
if (FS.isMountpoint(node)) {
|
|
throw new FS.ErrnoError(10);
|
|
}
|
|
try {
|
|
if (FS.trackingDelegate['willDeletePath']) {
|
|
FS.trackingDelegate['willDeletePath'](path);
|
|
}
|
|
} catch(e) {
|
|
console.log("FS.trackingDelegate['willDeletePath']('"+path+"') threw an exception: " + e.message);
|
|
}
|
|
parent.node_ops.unlink(parent, name);
|
|
FS.destroyNode(node);
|
|
try {
|
|
if (FS.trackingDelegate['onDeletePath']) FS.trackingDelegate['onDeletePath'](path);
|
|
} catch(e) {
|
|
console.log("FS.trackingDelegate['onDeletePath']('"+path+"') threw an exception: " + e.message);
|
|
}
|
|
},readlink:function(path) {
|
|
var lookup = FS.lookupPath(path);
|
|
var link = lookup.node;
|
|
if (!link) {
|
|
throw new FS.ErrnoError(44);
|
|
}
|
|
if (!link.node_ops.readlink) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link));
|
|
},stat:function(path, dontFollow) {
|
|
var lookup = FS.lookupPath(path, { follow: !dontFollow });
|
|
var node = lookup.node;
|
|
if (!node) {
|
|
throw new FS.ErrnoError(44);
|
|
}
|
|
if (!node.node_ops.getattr) {
|
|
throw new FS.ErrnoError(63);
|
|
}
|
|
return node.node_ops.getattr(node);
|
|
},lstat:function(path) {
|
|
return FS.stat(path, true);
|
|
},chmod:function(path, mode, dontFollow) {
|
|
var node;
|
|
if (typeof path === 'string') {
|
|
var lookup = FS.lookupPath(path, { follow: !dontFollow });
|
|
node = lookup.node;
|
|
} else {
|
|
node = path;
|
|
}
|
|
if (!node.node_ops.setattr) {
|
|
throw new FS.ErrnoError(63);
|
|
}
|
|
node.node_ops.setattr(node, {
|
|
mode: (mode & 4095) | (node.mode & ~4095),
|
|
timestamp: Date.now()
|
|
});
|
|
},lchmod:function(path, mode) {
|
|
FS.chmod(path, mode, true);
|
|
},fchmod:function(fd, mode) {
|
|
var stream = FS.getStream(fd);
|
|
if (!stream) {
|
|
throw new FS.ErrnoError(8);
|
|
}
|
|
FS.chmod(stream.node, mode);
|
|
},chown:function(path, uid, gid, dontFollow) {
|
|
var node;
|
|
if (typeof path === 'string') {
|
|
var lookup = FS.lookupPath(path, { follow: !dontFollow });
|
|
node = lookup.node;
|
|
} else {
|
|
node = path;
|
|
}
|
|
if (!node.node_ops.setattr) {
|
|
throw new FS.ErrnoError(63);
|
|
}
|
|
node.node_ops.setattr(node, {
|
|
timestamp: Date.now()
|
|
// we ignore the uid / gid for now
|
|
});
|
|
},lchown:function(path, uid, gid) {
|
|
FS.chown(path, uid, gid, true);
|
|
},fchown:function(fd, uid, gid) {
|
|
var stream = FS.getStream(fd);
|
|
if (!stream) {
|
|
throw new FS.ErrnoError(8);
|
|
}
|
|
FS.chown(stream.node, uid, gid);
|
|
},truncate:function(path, len) {
|
|
if (len < 0) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
var node;
|
|
if (typeof path === 'string') {
|
|
var lookup = FS.lookupPath(path, { follow: true });
|
|
node = lookup.node;
|
|
} else {
|
|
node = path;
|
|
}
|
|
if (!node.node_ops.setattr) {
|
|
throw new FS.ErrnoError(63);
|
|
}
|
|
if (FS.isDir(node.mode)) {
|
|
throw new FS.ErrnoError(31);
|
|
}
|
|
if (!FS.isFile(node.mode)) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
var err = FS.nodePermissions(node, 'w');
|
|
if (err) {
|
|
throw new FS.ErrnoError(err);
|
|
}
|
|
node.node_ops.setattr(node, {
|
|
size: len,
|
|
timestamp: Date.now()
|
|
});
|
|
},ftruncate:function(fd, len) {
|
|
var stream = FS.getStream(fd);
|
|
if (!stream) {
|
|
throw new FS.ErrnoError(8);
|
|
}
|
|
if ((stream.flags & 2097155) === 0) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
FS.truncate(stream.node, len);
|
|
},utime:function(path, atime, mtime) {
|
|
var lookup = FS.lookupPath(path, { follow: true });
|
|
var node = lookup.node;
|
|
node.node_ops.setattr(node, {
|
|
timestamp: Math.max(atime, mtime)
|
|
});
|
|
},open:function(path, flags, mode, fd_start, fd_end) {
|
|
if (path === "") {
|
|
throw new FS.ErrnoError(44);
|
|
}
|
|
flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
|
|
mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode;
|
|
if ((flags & 64)) {
|
|
mode = (mode & 4095) | 32768;
|
|
} else {
|
|
mode = 0;
|
|
}
|
|
var node;
|
|
if (typeof path === 'object') {
|
|
node = path;
|
|
} else {
|
|
path = PATH.normalize(path);
|
|
try {
|
|
var lookup = FS.lookupPath(path, {
|
|
follow: !(flags & 131072)
|
|
});
|
|
node = lookup.node;
|
|
} catch (e) {
|
|
// ignore
|
|
}
|
|
}
|
|
// perhaps we need to create the node
|
|
var created = false;
|
|
if ((flags & 64)) {
|
|
if (node) {
|
|
// if O_CREAT and O_EXCL are set, error out if the node already exists
|
|
if ((flags & 128)) {
|
|
throw new FS.ErrnoError(20);
|
|
}
|
|
} else {
|
|
// node doesn't exist, try to create it
|
|
node = FS.mknod(path, mode, 0);
|
|
created = true;
|
|
}
|
|
}
|
|
if (!node) {
|
|
throw new FS.ErrnoError(44);
|
|
}
|
|
// can't truncate a device
|
|
if (FS.isChrdev(node.mode)) {
|
|
flags &= ~512;
|
|
}
|
|
// if asked only for a directory, then this must be one
|
|
if ((flags & 65536) && !FS.isDir(node.mode)) {
|
|
throw new FS.ErrnoError(54);
|
|
}
|
|
// check permissions, if this is not a file we just created now (it is ok to
|
|
// create and write to a file with read-only permissions; it is read-only
|
|
// for later use)
|
|
if (!created) {
|
|
var err = FS.mayOpen(node, flags);
|
|
if (err) {
|
|
throw new FS.ErrnoError(err);
|
|
}
|
|
}
|
|
// do truncation if necessary
|
|
if ((flags & 512)) {
|
|
FS.truncate(node, 0);
|
|
}
|
|
// we've already handled these, don't pass down to the underlying vfs
|
|
flags &= ~(128 | 512);
|
|
|
|
// register the stream with the filesystem
|
|
var stream = FS.createStream({
|
|
node: node,
|
|
path: FS.getPath(node), // we want the absolute path to the node
|
|
flags: flags,
|
|
seekable: true,
|
|
position: 0,
|
|
stream_ops: node.stream_ops,
|
|
// used by the file family libc calls (fopen, fwrite, ferror, etc.)
|
|
ungotten: [],
|
|
error: false
|
|
}, fd_start, fd_end);
|
|
// call the new stream's open function
|
|
if (stream.stream_ops.open) {
|
|
stream.stream_ops.open(stream);
|
|
}
|
|
if (Module['logReadFiles'] && !(flags & 1)) {
|
|
if (!FS.readFiles) FS.readFiles = {};
|
|
if (!(path in FS.readFiles)) {
|
|
FS.readFiles[path] = 1;
|
|
console.log("FS.trackingDelegate error on read file: " + path);
|
|
}
|
|
}
|
|
try {
|
|
if (FS.trackingDelegate['onOpenFile']) {
|
|
var trackingFlags = 0;
|
|
if ((flags & 2097155) !== 1) {
|
|
trackingFlags |= FS.tracking.openFlags.READ;
|
|
}
|
|
if ((flags & 2097155) !== 0) {
|
|
trackingFlags |= FS.tracking.openFlags.WRITE;
|
|
}
|
|
FS.trackingDelegate['onOpenFile'](path, trackingFlags);
|
|
}
|
|
} catch(e) {
|
|
console.log("FS.trackingDelegate['onOpenFile']('"+path+"', flags) threw an exception: " + e.message);
|
|
}
|
|
return stream;
|
|
},close:function(stream) {
|
|
if (FS.isClosed(stream)) {
|
|
throw new FS.ErrnoError(8);
|
|
}
|
|
if (stream.getdents) stream.getdents = null; // free readdir state
|
|
try {
|
|
if (stream.stream_ops.close) {
|
|
stream.stream_ops.close(stream);
|
|
}
|
|
} catch (e) {
|
|
throw e;
|
|
} finally {
|
|
FS.closeStream(stream.fd);
|
|
}
|
|
stream.fd = null;
|
|
},isClosed:function(stream) {
|
|
return stream.fd === null;
|
|
},llseek:function(stream, offset, whence) {
|
|
if (FS.isClosed(stream)) {
|
|
throw new FS.ErrnoError(8);
|
|
}
|
|
if (!stream.seekable || !stream.stream_ops.llseek) {
|
|
throw new FS.ErrnoError(70);
|
|
}
|
|
if (whence != 0 && whence != 1 && whence != 2) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
stream.position = stream.stream_ops.llseek(stream, offset, whence);
|
|
stream.ungotten = [];
|
|
return stream.position;
|
|
},read:function(stream, buffer, offset, length, position) {
|
|
if (length < 0 || position < 0) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
if (FS.isClosed(stream)) {
|
|
throw new FS.ErrnoError(8);
|
|
}
|
|
if ((stream.flags & 2097155) === 1) {
|
|
throw new FS.ErrnoError(8);
|
|
}
|
|
if (FS.isDir(stream.node.mode)) {
|
|
throw new FS.ErrnoError(31);
|
|
}
|
|
if (!stream.stream_ops.read) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
var seeking = typeof position !== 'undefined';
|
|
if (!seeking) {
|
|
position = stream.position;
|
|
} else if (!stream.seekable) {
|
|
throw new FS.ErrnoError(70);
|
|
}
|
|
var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
|
|
if (!seeking) stream.position += bytesRead;
|
|
return bytesRead;
|
|
},write:function(stream, buffer, offset, length, position, canOwn) {
|
|
if (length < 0 || position < 0) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
if (FS.isClosed(stream)) {
|
|
throw new FS.ErrnoError(8);
|
|
}
|
|
if ((stream.flags & 2097155) === 0) {
|
|
throw new FS.ErrnoError(8);
|
|
}
|
|
if (FS.isDir(stream.node.mode)) {
|
|
throw new FS.ErrnoError(31);
|
|
}
|
|
if (!stream.stream_ops.write) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
if (stream.flags & 1024) {
|
|
// seek to the end before writing in append mode
|
|
FS.llseek(stream, 0, 2);
|
|
}
|
|
var seeking = typeof position !== 'undefined';
|
|
if (!seeking) {
|
|
position = stream.position;
|
|
} else if (!stream.seekable) {
|
|
throw new FS.ErrnoError(70);
|
|
}
|
|
var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
|
|
if (!seeking) stream.position += bytesWritten;
|
|
try {
|
|
if (stream.path && FS.trackingDelegate['onWriteToFile']) FS.trackingDelegate['onWriteToFile'](stream.path);
|
|
} catch(e) {
|
|
console.log("FS.trackingDelegate['onWriteToFile']('"+stream.path+"') threw an exception: " + e.message);
|
|
}
|
|
return bytesWritten;
|
|
},allocate:function(stream, offset, length) {
|
|
if (FS.isClosed(stream)) {
|
|
throw new FS.ErrnoError(8);
|
|
}
|
|
if (offset < 0 || length <= 0) {
|
|
throw new FS.ErrnoError(28);
|
|
}
|
|
if ((stream.flags & 2097155) === 0) {
|
|
throw new FS.ErrnoError(8);
|
|
}
|
|
if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
|
|
throw new FS.ErrnoError(43);
|
|
}
|
|
if (!stream.stream_ops.allocate) {
|
|
throw new FS.ErrnoError(138);
|
|
}
|
|
stream.stream_ops.allocate(stream, offset, length);
|
|
},mmap:function(stream, buffer, offset, length, position, prot, flags) {
|
|
// User requests writing to file (prot & PROT_WRITE != 0).
|
|
// Checking if we have permissions to write to the file unless
|
|
// MAP_PRIVATE flag is set. According to POSIX spec it is possible
|
|
// to write to file opened in read-only mode with MAP_PRIVATE flag,
|
|
// as all modifications will be visible only in the memory of
|
|
// the current process.
|
|
if ((prot & 2) !== 0
|
|
&& (flags & 2) === 0
|
|
&& (stream.flags & 2097155) !== 2) {
|
|
throw new FS.ErrnoError(2);
|
|
}
|
|
if ((stream.flags & 2097155) === 1) {
|
|
throw new FS.ErrnoError(2);
|
|
}
|
|
if (!stream.stream_ops.mmap) {
|
|
throw new FS.ErrnoError(43);
|
|
}
|
|
return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags);
|
|
},msync:function(stream, buffer, offset, length, mmapFlags) {
|
|
if (!stream || !stream.stream_ops.msync) {
|
|
return 0;
|
|
}
|
|
return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
|
|
},munmap:function(stream) {
|
|
return 0;
|
|
},ioctl:function(stream, cmd, arg) {
|
|
if (!stream.stream_ops.ioctl) {
|
|
throw new FS.ErrnoError(59);
|
|
}
|
|
return stream.stream_ops.ioctl(stream, cmd, arg);
|
|
},readFile:function(path, opts) {
|
|
opts = opts || {};
|
|
opts.flags = opts.flags || 'r';
|
|
opts.encoding = opts.encoding || 'binary';
|
|
if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
|
|
throw new Error('Invalid encoding type "' + opts.encoding + '"');
|
|
}
|
|
var ret;
|
|
var stream = FS.open(path, opts.flags);
|
|
var stat = FS.stat(path);
|
|
var length = stat.size;
|
|
var buf = new Uint8Array(length);
|
|
FS.read(stream, buf, 0, length, 0);
|
|
if (opts.encoding === 'utf8') {
|
|
ret = UTF8ArrayToString(buf, 0);
|
|
} else if (opts.encoding === 'binary') {
|
|
ret = buf;
|
|
}
|
|
FS.close(stream);
|
|
return ret;
|
|
},writeFile:function(path, data, opts) {
|
|
opts = opts || {};
|
|
opts.flags = opts.flags || 'w';
|
|
var stream = FS.open(path, opts.flags, opts.mode);
|
|
if (typeof data === 'string') {
|
|
var buf = new Uint8Array(lengthBytesUTF8(data)+1);
|
|
var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
|
|
FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn);
|
|
} else if (ArrayBuffer.isView(data)) {
|
|
FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn);
|
|
} else {
|
|
throw new Error('Unsupported data type');
|
|
}
|
|
FS.close(stream);
|
|
},cwd:function() {
|
|
return FS.currentPath;
|
|
},chdir:function(path) {
|
|
var lookup = FS.lookupPath(path, { follow: true });
|
|
if (lookup.node === null) {
|
|
throw new FS.ErrnoError(44);
|
|
}
|
|
if (!FS.isDir(lookup.node.mode)) {
|
|
throw new FS.ErrnoError(54);
|
|
}
|
|
var err = FS.nodePermissions(lookup.node, 'x');
|
|
if (err) {
|
|
throw new FS.ErrnoError(err);
|
|
}
|
|
FS.currentPath = lookup.path;
|
|
},createDefaultDirectories:function() {
|
|
FS.mkdir('/tmp');
|
|
FS.mkdir('/home');
|
|
FS.mkdir('/home/web_user');
|
|
},createDefaultDevices:function() {
|
|
// create /dev
|
|
FS.mkdir('/dev');
|
|
// setup /dev/null
|
|
FS.registerDevice(FS.makedev(1, 3), {
|
|
read: function() { return 0; },
|
|
write: function(stream, buffer, offset, length, pos) { return length; }
|
|
});
|
|
FS.mkdev('/dev/null', FS.makedev(1, 3));
|
|
// setup /dev/tty and /dev/tty1
|
|
// stderr needs to print output using Module['printErr']
|
|
// so we register a second tty just for it.
|
|
TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
|
|
TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
|
|
FS.mkdev('/dev/tty', FS.makedev(5, 0));
|
|
FS.mkdev('/dev/tty1', FS.makedev(6, 0));
|
|
// setup /dev/[u]random
|
|
var random_device;
|
|
if (typeof crypto === 'object' && typeof crypto['getRandomValues'] === 'function') {
|
|
// for modern web browsers
|
|
var randomBuffer = new Uint8Array(1);
|
|
random_device = function() { crypto.getRandomValues(randomBuffer); return randomBuffer[0]; };
|
|
} else
|
|
if (ENVIRONMENT_IS_NODE) {
|
|
// for nodejs with or without crypto support included
|
|
try {
|
|
var crypto_module = require('crypto');
|
|
// nodejs has crypto support
|
|
random_device = function() { return crypto_module['randomBytes'](1)[0]; };
|
|
} catch (e) {
|
|
// nodejs doesn't have crypto support
|
|
}
|
|
} else
|
|
{}
|
|
if (!random_device) {
|
|
// we couldn't find a proper implementation, as Math.random() is not suitable for /dev/random, see emscripten-core/emscripten/pull/7096
|
|
random_device = function() { abort("random_device"); };
|
|
}
|
|
FS.createDevice('/dev', 'random', random_device);
|
|
FS.createDevice('/dev', 'urandom', random_device);
|
|
// we're not going to emulate the actual shm device,
|
|
// just create the tmp dirs that reside in it commonly
|
|
FS.mkdir('/dev/shm');
|
|
FS.mkdir('/dev/shm/tmp');
|
|
},createSpecialDirectories:function() {
|
|
// create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the name of the stream for fd 6 (see test_unistd_ttyname)
|
|
FS.mkdir('/proc');
|
|
FS.mkdir('/proc/self');
|
|
FS.mkdir('/proc/self/fd');
|
|
FS.mount({
|
|
mount: function() {
|
|
var node = FS.createNode('/proc/self', 'fd', 16384 | 511 /* 0777 */, 73);
|
|
node.node_ops = {
|
|
lookup: function(parent, name) {
|
|
var fd = +name;
|
|
var stream = FS.getStream(fd);
|
|
if (!stream) throw new FS.ErrnoError(8);
|
|
var ret = {
|
|
parent: null,
|
|
mount: { mountpoint: 'fake' },
|
|
node_ops: { readlink: function() { return stream.path } }
|
|
};
|
|
ret.parent = ret; // make it look like a simple root node
|
|
return ret;
|
|
}
|
|
};
|
|
return node;
|
|
}
|
|
}, {}, '/proc/self/fd');
|
|
},createStandardStreams:function() {
|
|
// TODO deprecate the old functionality of a single
|
|
// input / output callback and that utilizes FS.createDevice
|
|
// and instead require a unique set of stream ops
|
|
|
|
// by default, we symlink the standard streams to the
|
|
// default tty devices. however, if the standard streams
|
|
// have been overwritten we create a unique device for
|
|
// them instead.
|
|
if (Module['stdin']) {
|
|
FS.createDevice('/dev', 'stdin', Module['stdin']);
|
|
} else {
|
|
FS.symlink('/dev/tty', '/dev/stdin');
|
|
}
|
|
if (Module['stdout']) {
|
|
FS.createDevice('/dev', 'stdout', null, Module['stdout']);
|
|
} else {
|
|
FS.symlink('/dev/tty', '/dev/stdout');
|
|
}
|
|
if (Module['stderr']) {
|
|
FS.createDevice('/dev', 'stderr', null, Module['stderr']);
|
|
} else {
|
|
FS.symlink('/dev/tty1', '/dev/stderr');
|
|
}
|
|
|
|
// open default streams for the stdin, stdout and stderr devices
|
|
var stdin = FS.open('/dev/stdin', 'r');
|
|
var stdout = FS.open('/dev/stdout', 'w');
|
|
var stderr = FS.open('/dev/stderr', 'w');
|
|
},ensureErrnoError:function() {
|
|
if (FS.ErrnoError) return;
|
|
FS.ErrnoError = function ErrnoError(errno, node) {
|
|
this.node = node;
|
|
this.setErrno = function(errno) {
|
|
this.errno = errno;
|
|
};
|
|
this.setErrno(errno);
|
|
this.message = 'FS error';
|
|
|
|
};
|
|
FS.ErrnoError.prototype = new Error();
|
|
FS.ErrnoError.prototype.constructor = FS.ErrnoError;
|
|
// Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
|
|
[44].forEach(function(code) {
|
|
FS.genericErrors[code] = new FS.ErrnoError(code);
|
|
FS.genericErrors[code].stack = '<generic error, no stack>';
|
|
});
|
|
},staticInit:function() {
|
|
FS.ensureErrnoError();
|
|
|
|
FS.nameTable = new Array(4096);
|
|
|
|
FS.mount(MEMFS, {}, '/');
|
|
|
|
FS.createDefaultDirectories();
|
|
FS.createDefaultDevices();
|
|
FS.createSpecialDirectories();
|
|
|
|
FS.filesystems = {
|
|
'MEMFS': MEMFS,
|
|
'NODEFS': NODEFS,
|
|
};
|
|
},init:function(input, output, error) {
|
|
FS.init.initialized = true;
|
|
|
|
FS.ensureErrnoError();
|
|
|
|
// Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
|
|
Module['stdin'] = input || Module['stdin'];
|
|
Module['stdout'] = output || Module['stdout'];
|
|
Module['stderr'] = error || Module['stderr'];
|
|
|
|
FS.createStandardStreams();
|
|
},quit:function() {
|
|
FS.init.initialized = false;
|
|
// force-flush all streams, so we get musl std streams printed out
|
|
var fflush = Module['_fflush'];
|
|
if (fflush) fflush(0);
|
|
// close all of our streams
|
|
for (var i = 0; i < FS.streams.length; i++) {
|
|
var stream = FS.streams[i];
|
|
if (!stream) {
|
|
continue;
|
|
}
|
|
FS.close(stream);
|
|
}
|
|
},getMode:function(canRead, canWrite) {
|
|
var mode = 0;
|
|
if (canRead) mode |= 292 | 73;
|
|
if (canWrite) mode |= 146;
|
|
return mode;
|
|
},joinPath:function(parts, forceRelative) {
|
|
var path = PATH.join.apply(null, parts);
|
|
if (forceRelative && path[0] == '/') path = path.substr(1);
|
|
return path;
|
|
},absolutePath:function(relative, base) {
|
|
return PATH_FS.resolve(base, relative);
|
|
},standardizePath:function(path) {
|
|
return PATH.normalize(path);
|
|
},findObject:function(path, dontResolveLastLink) {
|
|
var ret = FS.analyzePath(path, dontResolveLastLink);
|
|
if (ret.exists) {
|
|
return ret.object;
|
|
} else {
|
|
___setErrNo(ret.error);
|
|
return null;
|
|
}
|
|
},analyzePath:function(path, dontResolveLastLink) {
|
|
// operate from within the context of the symlink's target
|
|
try {
|
|
var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
|
|
path = lookup.path;
|
|
} catch (e) {
|
|
}
|
|
var ret = {
|
|
isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
|
|
parentExists: false, parentPath: null, parentObject: null
|
|
};
|
|
try {
|
|
var lookup = FS.lookupPath(path, { parent: true });
|
|
ret.parentExists = true;
|
|
ret.parentPath = lookup.path;
|
|
ret.parentObject = lookup.node;
|
|
ret.name = PATH.basename(path);
|
|
lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
|
|
ret.exists = true;
|
|
ret.path = lookup.path;
|
|
ret.object = lookup.node;
|
|
ret.name = lookup.node.name;
|
|
ret.isRoot = lookup.path === '/';
|
|
} catch (e) {
|
|
ret.error = e.errno;
|
|
};
|
|
return ret;
|
|
},createFolder:function(parent, name, canRead, canWrite) {
|
|
var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
|
|
var mode = FS.getMode(canRead, canWrite);
|
|
return FS.mkdir(path, mode);
|
|
},createPath:function(parent, path, canRead, canWrite) {
|
|
parent = typeof parent === 'string' ? parent : FS.getPath(parent);
|
|
var parts = path.split('/').reverse();
|
|
while (parts.length) {
|
|
var part = parts.pop();
|
|
if (!part) continue;
|
|
var current = PATH.join2(parent, part);
|
|
try {
|
|
FS.mkdir(current);
|
|
} catch (e) {
|
|
// ignore EEXIST
|
|
}
|
|
parent = current;
|
|
}
|
|
return current;
|
|
},createFile:function(parent, name, properties, canRead, canWrite) {
|
|
var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
|
|
var mode = FS.getMode(canRead, canWrite);
|
|
return FS.create(path, mode);
|
|
},createDataFile:function(parent, name, data, canRead, canWrite, canOwn) {
|
|
var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
|
|
var mode = FS.getMode(canRead, canWrite);
|
|
var node = FS.create(path, mode);
|
|
if (data) {
|
|
if (typeof data === 'string') {
|
|
var arr = new Array(data.length);
|
|
for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
|
|
data = arr;
|
|
}
|
|
// make sure we can write to the file
|
|
FS.chmod(node, mode | 146);
|
|
var stream = FS.open(node, 'w');
|
|
FS.write(stream, data, 0, data.length, 0, canOwn);
|
|
FS.close(stream);
|
|
FS.chmod(node, mode);
|
|
}
|
|
return node;
|
|
},createDevice:function(parent, name, input, output) {
|
|
var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
|
|
var mode = FS.getMode(!!input, !!output);
|
|
if (!FS.createDevice.major) FS.createDevice.major = 64;
|
|
var dev = FS.makedev(FS.createDevice.major++, 0);
|
|
// Create a fake device that a set of stream ops to emulate
|
|
// the old behavior.
|
|
FS.registerDevice(dev, {
|
|
open: function(stream) {
|
|
stream.seekable = false;
|
|
},
|
|
close: function(stream) {
|
|
// flush any pending line data
|
|
if (output && output.buffer && output.buffer.length) {
|
|
output(10);
|
|
}
|
|
},
|
|
read: function(stream, buffer, offset, length, pos /* ignored */) {
|
|
var bytesRead = 0;
|
|
for (var i = 0; i < length; i++) {
|
|
var result;
|
|
try {
|
|
result = input();
|
|
} catch (e) {
|
|
throw new FS.ErrnoError(29);
|
|
}
|
|
if (result === undefined && bytesRead === 0) {
|
|
throw new FS.ErrnoError(6);
|
|
}
|
|
if (result === null || result === undefined) break;
|
|
bytesRead++;
|
|
buffer[offset+i] = result;
|
|
}
|
|
if (bytesRead) {
|
|
stream.node.timestamp = Date.now();
|
|
}
|
|
return bytesRead;
|
|
},
|
|
write: function(stream, buffer, offset, length, pos) {
|
|
for (var i = 0; i < length; i++) {
|
|
try {
|
|
output(buffer[offset+i]);
|
|
} catch (e) {
|
|
throw new FS.ErrnoError(29);
|
|
}
|
|
}
|
|
if (length) {
|
|
stream.node.timestamp = Date.now();
|
|
}
|
|
return i;
|
|
}
|
|
});
|
|
return FS.mkdev(path, mode, dev);
|
|
},createLink:function(parent, name, target, canRead, canWrite) {
|
|
var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
|
|
return FS.symlink(target, path);
|
|
},forceLoadFile:function(obj) {
|
|
if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
|
|
var success = true;
|
|
if (typeof XMLHttpRequest !== 'undefined') {
|
|
throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
|
|
} else if (read_) {
|
|
// Command-line.
|
|
try {
|
|
// WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
|
|
// read() will try to parse UTF8.
|
|
obj.contents = intArrayFromString(read_(obj.url), true);
|
|
obj.usedBytes = obj.contents.length;
|
|
} catch (e) {
|
|
success = false;
|
|
}
|
|
} else {
|
|
throw new Error('Cannot load without read() or XMLHttpRequest.');
|
|
}
|
|
if (!success) ___setErrNo(29);
|
|
return success;
|
|
},createLazyFile:function(parent, name, url, canRead, canWrite) {
|
|
// Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
|
|
function LazyUint8Array() {
|
|
this.lengthKnown = false;
|
|
this.chunks = []; // Loaded chunks. Index is the chunk number
|
|
}
|
|
LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
|
|
if (idx > this.length-1 || idx < 0) {
|
|
return undefined;
|
|
}
|
|
var chunkOffset = idx % this.chunkSize;
|
|
var chunkNum = (idx / this.chunkSize)|0;
|
|
return this.getter(chunkNum)[chunkOffset];
|
|
};
|
|
LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
|
|
this.getter = getter;
|
|
};
|
|
LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
|
|
// Find length
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('HEAD', url, false);
|
|
xhr.send(null);
|
|
if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
|
|
var datalength = Number(xhr.getResponseHeader("Content-length"));
|
|
var header;
|
|
var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
|
|
var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
|
|
|
|
var chunkSize = 1024*1024; // Chunk size in bytes
|
|
|
|
if (!hasByteServing) chunkSize = datalength;
|
|
|
|
// Function to get a range from the remote URL.
|
|
var doXHR = (function(from, to) {
|
|
if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
|
|
if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
|
|
|
|
// TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('GET', url, false);
|
|
if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
|
|
|
|
// Some hints to the browser that we want binary data.
|
|
if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
|
|
if (xhr.overrideMimeType) {
|
|
xhr.overrideMimeType('text/plain; charset=x-user-defined');
|
|
}
|
|
|
|
xhr.send(null);
|
|
if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
|
|
if (xhr.response !== undefined) {
|
|
return new Uint8Array(xhr.response || []);
|
|
} else {
|
|
return intArrayFromString(xhr.responseText || '', true);
|
|
}
|
|
});
|
|
var lazyArray = this;
|
|
lazyArray.setDataGetter(function(chunkNum) {
|
|
var start = chunkNum * chunkSize;
|
|
var end = (chunkNum+1) * chunkSize - 1; // including this byte
|
|
end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
|
|
if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
|
|
lazyArray.chunks[chunkNum] = doXHR(start, end);
|
|
}
|
|
if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
|
|
return lazyArray.chunks[chunkNum];
|
|
});
|
|
|
|
if (usesGzip || !datalength) {
|
|
// if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length
|
|
chunkSize = datalength = 1; // this will force getter(0)/doXHR do download the whole file
|
|
datalength = this.getter(0).length;
|
|
chunkSize = datalength;
|
|
console.log("LazyFiles on gzip forces download of the whole file when length is accessed");
|
|
}
|
|
|
|
this._length = datalength;
|
|
this._chunkSize = chunkSize;
|
|
this.lengthKnown = true;
|
|
};
|
|
if (typeof XMLHttpRequest !== 'undefined') {
|
|
if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
|
|
var lazyArray = new LazyUint8Array();
|
|
Object.defineProperties(lazyArray, {
|
|
length: {
|
|
get: function() {
|
|
if(!this.lengthKnown) {
|
|
this.cacheLength();
|
|
}
|
|
return this._length;
|
|
}
|
|
},
|
|
chunkSize: {
|
|
get: function() {
|
|
if(!this.lengthKnown) {
|
|
this.cacheLength();
|
|
}
|
|
return this._chunkSize;
|
|
}
|
|
}
|
|
});
|
|
|
|
var properties = { isDevice: false, contents: lazyArray };
|
|
} else {
|
|
var properties = { isDevice: false, url: url };
|
|
}
|
|
|
|
var node = FS.createFile(parent, name, properties, canRead, canWrite);
|
|
// This is a total hack, but I want to get this lazy file code out of the
|
|
// core of MEMFS. If we want to keep this lazy file concept I feel it should
|
|
// be its own thin LAZYFS proxying calls to MEMFS.
|
|
if (properties.contents) {
|
|
node.contents = properties.contents;
|
|
} else if (properties.url) {
|
|
node.contents = null;
|
|
node.url = properties.url;
|
|
}
|
|
// Add a function that defers querying the file size until it is asked the first time.
|
|
Object.defineProperties(node, {
|
|
usedBytes: {
|
|
get: function() { return this.contents.length; }
|
|
}
|
|
});
|
|
// override each stream op with one that tries to force load the lazy file first
|
|
var stream_ops = {};
|
|
var keys = Object.keys(node.stream_ops);
|
|
keys.forEach(function(key) {
|
|
var fn = node.stream_ops[key];
|
|
stream_ops[key] = function forceLoadLazyFile() {
|
|
if (!FS.forceLoadFile(node)) {
|
|
throw new FS.ErrnoError(29);
|
|
}
|
|
return fn.apply(null, arguments);
|
|
};
|
|
});
|
|
// use a custom read function
|
|
stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
|
|
if (!FS.forceLoadFile(node)) {
|
|
throw new FS.ErrnoError(29);
|
|
}
|
|
var contents = stream.node.contents;
|
|
if (position >= contents.length)
|
|
return 0;
|
|
var size = Math.min(contents.length - position, length);
|
|
if (contents.slice) { // normal array
|
|
for (var i = 0; i < size; i++) {
|
|
buffer[offset + i] = contents[position + i];
|
|
}
|
|
} else {
|
|
for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
|
|
buffer[offset + i] = contents.get(position + i);
|
|
}
|
|
}
|
|
return size;
|
|
};
|
|
node.stream_ops = stream_ops;
|
|
return node;
|
|
},createPreloadedFile:function(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) {
|
|
Browser.init(); // XXX perhaps this method should move onto Browser?
|
|
// TODO we should allow people to just pass in a complete filename instead
|
|
// of parent and name being that we just join them anyways
|
|
var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
|
|
var dep = getUniqueRunDependency('cp ' + fullname); // might have several active requests for the same fullname
|
|
function processData(byteArray) {
|
|
function finish(byteArray) {
|
|
if (preFinish) preFinish();
|
|
if (!dontCreateFile) {
|
|
FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
|
|
}
|
|
if (onload) onload();
|
|
removeRunDependency(dep);
|
|
}
|
|
var handled = false;
|
|
Module['preloadPlugins'].forEach(function(plugin) {
|
|
if (handled) return;
|
|
if (plugin['canHandle'](fullname)) {
|
|
plugin['handle'](byteArray, fullname, finish, function() {
|
|
if (onerror) onerror();
|
|
removeRunDependency(dep);
|
|
});
|
|
handled = true;
|
|
}
|
|
});
|
|
if (!handled) finish(byteArray);
|
|
}
|
|
addRunDependency(dep);
|
|
if (typeof url == 'string') {
|
|
Browser.asyncLoad(url, function(byteArray) {
|
|
processData(byteArray);
|
|
}, onerror);
|
|
} else {
|
|
processData(url);
|
|
}
|
|
},indexedDB:function() {
|
|
return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
|
|
},DB_NAME:function() {
|
|
return 'EM_FS_' + window.location.pathname;
|
|
},DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function(paths, onload, onerror) {
|
|
onload = onload || function(){};
|
|
onerror = onerror || function(){};
|
|
var indexedDB = FS.indexedDB();
|
|
try {
|
|
var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
|
|
} catch (e) {
|
|
return onerror(e);
|
|
}
|
|
openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
|
|
console.log('creating db');
|
|
var db = openRequest.result;
|
|
db.createObjectStore(FS.DB_STORE_NAME);
|
|
};
|
|
openRequest.onsuccess = function openRequest_onsuccess() {
|
|
var db = openRequest.result;
|
|
var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
|
|
var files = transaction.objectStore(FS.DB_STORE_NAME);
|
|
var ok = 0, fail = 0, total = paths.length;
|
|
function finish() {
|
|
if (fail == 0) onload(); else onerror();
|
|
}
|
|
paths.forEach(function(path) {
|
|
var putRequest = files.put(FS.analyzePath(path).object.contents, path);
|
|
putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
|
|
putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
|
|
});
|
|
transaction.onerror = onerror;
|
|
};
|
|
openRequest.onerror = onerror;
|
|
},loadFilesFromDB:function(paths, onload, onerror) {
|
|
onload = onload || function(){};
|
|
onerror = onerror || function(){};
|
|
var indexedDB = FS.indexedDB();
|
|
try {
|
|
var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
|
|
} catch (e) {
|
|
return onerror(e);
|
|
}
|
|
openRequest.onupgradeneeded = onerror; // no database to load from
|
|
openRequest.onsuccess = function openRequest_onsuccess() {
|
|
var db = openRequest.result;
|
|
try {
|
|
var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
|
|
} catch(e) {
|
|
onerror(e);
|
|
return;
|
|
}
|
|
var files = transaction.objectStore(FS.DB_STORE_NAME);
|
|
var ok = 0, fail = 0, total = paths.length;
|
|
function finish() {
|
|
if (fail == 0) onload(); else onerror();
|
|
}
|
|
paths.forEach(function(path) {
|
|
var getRequest = files.get(path);
|
|
getRequest.onsuccess = function getRequest_onsuccess() {
|
|
if (FS.analyzePath(path).exists) {
|
|
FS.unlink(path);
|
|
}
|
|
FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
|
|
ok++;
|
|
if (ok + fail == total) finish();
|
|
};
|
|
getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
|
|
});
|
|
transaction.onerror = onerror;
|
|
};
|
|
openRequest.onerror = onerror;
|
|
}};
|
|
Module["FS"] = FS;var SYSCALLS={DEFAULT_POLLMASK:5,mappings:{},umask:511,calculateAt:function(dirfd, path) {
|
|
if (path[0] !== '/') {
|
|
// relative path
|
|
var dir;
|
|
if (dirfd === -100) {
|
|
dir = FS.cwd();
|
|
} else {
|
|
var dirstream = FS.getStream(dirfd);
|
|
if (!dirstream) throw new FS.ErrnoError(8);
|
|
dir = dirstream.path;
|
|
}
|
|
path = PATH.join2(dir, path);
|
|
}
|
|
return path;
|
|
},doStat:function(func, path, buf) {
|
|
try {
|
|
var stat = func(path);
|
|
} catch (e) {
|
|
if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) {
|
|
// an error occurred while trying to look up the path; we should just report ENOTDIR
|
|
return -54;
|
|
}
|
|
throw e;
|
|
}
|
|
HEAP32[((buf)>>2)]=stat.dev;
|
|
HEAP32[(((buf)+(4))>>2)]=0;
|
|
HEAP32[(((buf)+(8))>>2)]=stat.ino;
|
|
HEAP32[(((buf)+(12))>>2)]=stat.mode;
|
|
HEAP32[(((buf)+(16))>>2)]=stat.nlink;
|
|
HEAP32[(((buf)+(20))>>2)]=stat.uid;
|
|
HEAP32[(((buf)+(24))>>2)]=stat.gid;
|
|
HEAP32[(((buf)+(28))>>2)]=stat.rdev;
|
|
HEAP32[(((buf)+(32))>>2)]=0;
|
|
(tempI64 = [stat.size>>>0,(tempDouble=stat.size,(+(Math_abs(tempDouble))) >= 1.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[(((buf)+(40))>>2)]=tempI64[0],HEAP32[(((buf)+(44))>>2)]=tempI64[1]);
|
|
HEAP32[(((buf)+(48))>>2)]=4096;
|
|
HEAP32[(((buf)+(52))>>2)]=stat.blocks;
|
|
HEAP32[(((buf)+(56))>>2)]=(stat.atime.getTime() / 1000)|0;
|
|
HEAP32[(((buf)+(60))>>2)]=0;
|
|
HEAP32[(((buf)+(64))>>2)]=(stat.mtime.getTime() / 1000)|0;
|
|
HEAP32[(((buf)+(68))>>2)]=0;
|
|
HEAP32[(((buf)+(72))>>2)]=(stat.ctime.getTime() / 1000)|0;
|
|
HEAP32[(((buf)+(76))>>2)]=0;
|
|
(tempI64 = [stat.ino>>>0,(tempDouble=stat.ino,(+(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[(((buf)+(80))>>2)]=tempI64[0],HEAP32[(((buf)+(84))>>2)]=tempI64[1]);
|
|
return 0;
|
|
},doMsync:function(addr, stream, len, flags) {
|
|
var buffer = new Uint8Array(HEAPU8.subarray(addr, addr + len));
|
|
FS.msync(stream, buffer, 0, len, flags);
|
|
},doMkdir:function(path, mode) {
|
|
// remove a trailing slash, if one - /a/b/ has basename of '', but
|
|
// we want to create b in the context of this function
|
|
path = PATH.normalize(path);
|
|
if (path[path.length-1] === '/') path = path.substr(0, path.length-1);
|
|
FS.mkdir(path, mode, 0);
|
|
return 0;
|
|
},doMknod:function(path, mode, dev) {
|
|
// we don't want this in the JS API as it uses mknod to create all nodes.
|
|
switch (mode & 61440) {
|
|
case 32768:
|
|
case 8192:
|
|
case 24576:
|
|
case 4096:
|
|
case 49152:
|
|
break;
|
|
default: return -28;
|
|
}
|
|
FS.mknod(path, mode, dev);
|
|
return 0;
|
|
},doReadlink:function(path, buf, bufsize) {
|
|
if (bufsize <= 0) return -28;
|
|
var ret = FS.readlink(path);
|
|
|
|
var len = Math.min(bufsize, lengthBytesUTF8(ret));
|
|
var endChar = HEAP8[buf+len];
|
|
stringToUTF8(ret, buf, bufsize+1);
|
|
// readlink is one of the rare functions that write out a C string, but does never append a null to the output buffer(!)
|
|
// stringToUTF8() always appends a null byte, so restore the character under the null byte after the write.
|
|
HEAP8[buf+len] = endChar;
|
|
|
|
return len;
|
|
},doAccess:function(path, amode) {
|
|
if (amode & ~7) {
|
|
// need a valid mode
|
|
return -28;
|
|
}
|
|
var node;
|
|
var lookup = FS.lookupPath(path, { follow: true });
|
|
node = lookup.node;
|
|
if (!node) {
|
|
return -44;
|
|
}
|
|
var perms = '';
|
|
if (amode & 4) perms += 'r';
|
|
if (amode & 2) perms += 'w';
|
|
if (amode & 1) perms += 'x';
|
|
if (perms /* otherwise, they've just passed F_OK */ && FS.nodePermissions(node, perms)) {
|
|
return -2;
|
|
}
|
|
return 0;
|
|
},doDup:function(path, flags, suggestFD) {
|
|
var suggest = FS.getStream(suggestFD);
|
|
if (suggest) FS.close(suggest);
|
|
return FS.open(path, flags, 0, suggestFD, suggestFD).fd;
|
|
},doReadv:function(stream, iov, iovcnt, offset) {
|
|
var ret = 0;
|
|
for (var i = 0; i < iovcnt; i++) {
|
|
var ptr = HEAP32[(((iov)+(i*8))>>2)];
|
|
var len = HEAP32[(((iov)+(i*8 + 4))>>2)];
|
|
var curr = FS.read(stream, HEAP8,ptr, len, offset);
|
|
if (curr < 0) return -1;
|
|
ret += curr;
|
|
if (curr < len) break; // nothing more to read
|
|
}
|
|
return ret;
|
|
},doWritev:function(stream, iov, iovcnt, offset) {
|
|
var ret = 0;
|
|
for (var i = 0; i < iovcnt; i++) {
|
|
var ptr = HEAP32[(((iov)+(i*8))>>2)];
|
|
var len = HEAP32[(((iov)+(i*8 + 4))>>2)];
|
|
var curr = FS.write(stream, HEAP8,ptr, len, offset);
|
|
if (curr < 0) return -1;
|
|
ret += curr;
|
|
}
|
|
return ret;
|
|
},varargs:0,get:function(varargs) {
|
|
SYSCALLS.varargs += 4;
|
|
var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)];
|
|
return ret;
|
|
},getStr:function() {
|
|
var ret = UTF8ToString(SYSCALLS.get());
|
|
return ret;
|
|
},getStreamFromFD:function(fd) {
|
|
// TODO: when all syscalls use wasi, can remove the next line
|
|
if (fd === undefined) fd = SYSCALLS.get();
|
|
var stream = FS.getStream(fd);
|
|
if (!stream) throw new FS.ErrnoError(8);
|
|
return stream;
|
|
},get64:function() {
|
|
var low = SYSCALLS.get(), high = SYSCALLS.get();
|
|
return low;
|
|
},getZero:function() {
|
|
SYSCALLS.get();
|
|
}};
|
|
Module["SYSCALLS"] = SYSCALLS;function ___syscall10(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(2, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// unlink
|
|
var path = SYSCALLS.getStr();
|
|
FS.unlink(path);
|
|
return 0;
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall10"] = ___syscall10;
|
|
|
|
function ___syscall12(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(3, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// chdir
|
|
var path = SYSCALLS.getStr();
|
|
FS.chdir(path);
|
|
return 0;
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall12"] = ___syscall12;
|
|
|
|
function ___syscall183(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(4, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// getcwd
|
|
var buf = SYSCALLS.get(), size = SYSCALLS.get();
|
|
if (size === 0) return -28;
|
|
var cwd = FS.cwd();
|
|
var cwdLengthInBytes = lengthBytesUTF8(cwd);
|
|
if (size < cwdLengthInBytes + 1) return -68;
|
|
stringToUTF8(cwd, buf, size);
|
|
return buf;
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall183"] = ___syscall183;
|
|
|
|
function ___syscall195(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(5, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// SYS_stat64
|
|
var path = SYSCALLS.getStr(), buf = SYSCALLS.get();
|
|
return SYSCALLS.doStat(FS.stat, path, buf);
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall195"] = ___syscall195;
|
|
|
|
function ___syscall196(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(6, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// SYS_lstat64
|
|
var path = SYSCALLS.getStr(), buf = SYSCALLS.get();
|
|
return SYSCALLS.doStat(FS.lstat, path, buf);
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall196"] = ___syscall196;
|
|
|
|
function ___syscall220(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(7, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// SYS_getdents64
|
|
var stream = SYSCALLS.getStreamFromFD(), dirp = SYSCALLS.get(), count = SYSCALLS.get();
|
|
if (!stream.getdents) {
|
|
stream.getdents = FS.readdir(stream.path);
|
|
}
|
|
|
|
var struct_size = 280;
|
|
var pos = 0;
|
|
var off = FS.llseek(stream, 0, 1);
|
|
|
|
var idx = Math.floor(off / struct_size);
|
|
|
|
while (idx < stream.getdents.length && pos + struct_size <= count) {
|
|
var id;
|
|
var type;
|
|
var name = stream.getdents[idx];
|
|
if (name[0] === '.') {
|
|
id = 1;
|
|
type = 4; // DT_DIR
|
|
} else {
|
|
var child = FS.lookupNode(stream.node, name);
|
|
id = child.id;
|
|
type = FS.isChrdev(child.mode) ? 2 : // DT_CHR, character device.
|
|
FS.isDir(child.mode) ? 4 : // DT_DIR, directory.
|
|
FS.isLink(child.mode) ? 10 : // DT_LNK, symbolic link.
|
|
8; // DT_REG, regular file.
|
|
}
|
|
(tempI64 = [id>>>0,(tempDouble=id,(+(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[((dirp + pos)>>2)]=tempI64[0],HEAP32[(((dirp + pos)+(4))>>2)]=tempI64[1]);
|
|
(tempI64 = [(idx + 1) * struct_size>>>0,(tempDouble=(idx + 1) * struct_size,(+(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[(((dirp + pos)+(8))>>2)]=tempI64[0],HEAP32[(((dirp + pos)+(12))>>2)]=tempI64[1]);
|
|
HEAP16[(((dirp + pos)+(16))>>1)]=280;
|
|
HEAP8[(((dirp + pos)+(18))>>0)]=type;
|
|
stringToUTF8(name, dirp + pos + 19, 256);
|
|
pos += struct_size;
|
|
idx += 1;
|
|
}
|
|
FS.llseek(stream, idx * struct_size, 0);
|
|
return pos;
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall220"] = ___syscall220;
|
|
|
|
function ___syscall221(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(8, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// fcntl64
|
|
var stream = SYSCALLS.getStreamFromFD(), cmd = SYSCALLS.get();
|
|
switch (cmd) {
|
|
case 0: {
|
|
var arg = SYSCALLS.get();
|
|
if (arg < 0) {
|
|
return -28;
|
|
}
|
|
var newStream;
|
|
newStream = FS.open(stream.path, stream.flags, 0, arg);
|
|
return newStream.fd;
|
|
}
|
|
case 1:
|
|
case 2:
|
|
return 0; // FD_CLOEXEC makes no sense for a single process.
|
|
case 3:
|
|
return stream.flags;
|
|
case 4: {
|
|
var arg = SYSCALLS.get();
|
|
stream.flags |= arg;
|
|
return 0;
|
|
}
|
|
case 12:
|
|
/* case 12: Currently in musl F_GETLK64 has same value as F_GETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ {
|
|
|
|
var arg = SYSCALLS.get();
|
|
var offset = 0;
|
|
// We're always unlocked.
|
|
HEAP16[(((arg)+(offset))>>1)]=2;
|
|
return 0;
|
|
}
|
|
case 13:
|
|
case 14:
|
|
/* case 13: Currently in musl F_SETLK64 has same value as F_SETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */
|
|
/* case 14: Currently in musl F_SETLKW64 has same value as F_SETLKW, so omitted to avoid duplicate case blocks. If that changes, uncomment this */
|
|
|
|
|
|
return 0; // Pretend that the locking is successful.
|
|
case 16:
|
|
case 8:
|
|
return -28; // These are for sockets. We don't have them fully implemented yet.
|
|
case 9:
|
|
// musl trusts getown return values, due to a bug where they must be, as they overlap with errors. just return -1 here, so fnctl() returns that, and we set errno ourselves.
|
|
___setErrNo(28);
|
|
return -1;
|
|
default: {
|
|
return -28;
|
|
}
|
|
}
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall221"] = ___syscall221;
|
|
|
|
function ___syscall3(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(9, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// read
|
|
var stream = SYSCALLS.getStreamFromFD(), buf = SYSCALLS.get(), count = SYSCALLS.get();
|
|
return FS.read(stream, HEAP8,buf, count);
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall3"] = ___syscall3;
|
|
|
|
function ___syscall39(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(10, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// mkdir
|
|
var path = SYSCALLS.getStr(), mode = SYSCALLS.get();
|
|
return SYSCALLS.doMkdir(path, mode);
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall39"] = ___syscall39;
|
|
|
|
function ___syscall4(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(11, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// write
|
|
var stream = SYSCALLS.getStreamFromFD(), buf = SYSCALLS.get(), count = SYSCALLS.get();
|
|
return FS.write(stream, HEAP8,buf, count);
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall4"] = ___syscall4;
|
|
|
|
function ___syscall40(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(12, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// rmdir
|
|
var path = SYSCALLS.getStr();
|
|
FS.rmdir(path);
|
|
return 0;
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall40"] = ___syscall40;
|
|
|
|
function ___syscall5(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(13, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// open
|
|
var pathname = SYSCALLS.getStr(), flags = SYSCALLS.get(), mode = SYSCALLS.get(); // optional TODO
|
|
var stream = FS.open(pathname, flags, mode);
|
|
return stream.fd;
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall5"] = ___syscall5;
|
|
|
|
function ___syscall54(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(14, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// ioctl
|
|
var stream = SYSCALLS.getStreamFromFD(), op = SYSCALLS.get();
|
|
switch (op) {
|
|
case 21509:
|
|
case 21505: {
|
|
if (!stream.tty) return -59;
|
|
return 0;
|
|
}
|
|
case 21510:
|
|
case 21511:
|
|
case 21512:
|
|
case 21506:
|
|
case 21507:
|
|
case 21508: {
|
|
if (!stream.tty) return -59;
|
|
return 0; // no-op, not actually adjusting terminal settings
|
|
}
|
|
case 21519: {
|
|
if (!stream.tty) return -59;
|
|
var argp = SYSCALLS.get();
|
|
HEAP32[((argp)>>2)]=0;
|
|
return 0;
|
|
}
|
|
case 21520: {
|
|
if (!stream.tty) return -59;
|
|
return -28; // not supported
|
|
}
|
|
case 21531: {
|
|
var argp = SYSCALLS.get();
|
|
return FS.ioctl(stream, op, argp);
|
|
}
|
|
case 21523: {
|
|
// TODO: in theory we should write to the winsize struct that gets
|
|
// passed in, but for now musl doesn't read anything on it
|
|
if (!stream.tty) return -59;
|
|
return 0;
|
|
}
|
|
case 21524: {
|
|
// TODO: technically, this ioctl call should change the window size.
|
|
// but, since emscripten doesn't have any concept of a terminal window
|
|
// yet, we'll just silently throw it away as we do TIOCGWINSZ
|
|
if (!stream.tty) return -59;
|
|
return 0;
|
|
}
|
|
default: abort('bad ioctl syscall ' + op);
|
|
}
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall54"] = ___syscall54;
|
|
|
|
function ___syscall85(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(15, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// readlink
|
|
var path = SYSCALLS.getStr(), buf = SYSCALLS.get(), bufsize = SYSCALLS.get();
|
|
return SYSCALLS.doReadlink(path, buf, bufsize);
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall85"] = ___syscall85;
|
|
|
|
|
|
function __emscripten_syscall_munmap(addr, len) {
|
|
if (addr === -1 || len === 0) {
|
|
return -28;
|
|
}
|
|
// TODO: support unmmap'ing parts of allocations
|
|
var info = SYSCALLS.mappings[addr];
|
|
if (!info) return 0;
|
|
if (len === info.len) {
|
|
var stream = FS.getStream(info.fd);
|
|
SYSCALLS.doMsync(addr, stream, len, info.flags);
|
|
FS.munmap(stream);
|
|
SYSCALLS.mappings[addr] = null;
|
|
if (info.allocated) {
|
|
_free(info.malloc);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
Module["__emscripten_syscall_munmap"] = __emscripten_syscall_munmap;function ___syscall91(which, varargs) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(16, 1, which, varargs);
|
|
SYSCALLS.varargs = varargs;
|
|
try {
|
|
// munmap
|
|
var addr = SYSCALLS.get(), len = SYSCALLS.get();
|
|
return __emscripten_syscall_munmap(addr, len);
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return -e.errno;
|
|
}
|
|
}
|
|
|
|
Module["___syscall91"] = ___syscall91;
|
|
|
|
function ___unlock() {}
|
|
Module["___unlock"] = ___unlock;
|
|
|
|
function _abort() {
|
|
abort();
|
|
}
|
|
Module["_abort"] = _abort;
|
|
|
|
|
|
function _emscripten_check_blocking_allowed() {
|
|
}
|
|
Module["_emscripten_check_blocking_allowed"] = _emscripten_check_blocking_allowed;
|
|
|
|
|
|
function _emscripten_conditional_set_current_thread_status_js(expectedStatus, newStatus) {
|
|
}
|
|
Module["_emscripten_conditional_set_current_thread_status_js"] = _emscripten_conditional_set_current_thread_status_js;function _emscripten_conditional_set_current_thread_status(expectedStatus, newStatus) {
|
|
expectedStatus = expectedStatus|0;
|
|
newStatus = newStatus|0;
|
|
}
|
|
Module["_emscripten_conditional_set_current_thread_status"] = _emscripten_conditional_set_current_thread_status;
|
|
|
|
function _emscripten_futex_wait(addr, val, timeout) {
|
|
if (addr <= 0 || addr > HEAP8.length || addr&3 != 0) return -28;
|
|
// dump('futex_wait addr:' + addr + ' by thread: ' + _pthread_self() + (ENVIRONMENT_IS_PTHREAD?'(pthread)':'') + '\n');
|
|
if (ENVIRONMENT_IS_WORKER) {
|
|
var ret = Atomics.wait(HEAP32, addr >> 2, val, timeout);
|
|
// dump('futex_wait done by thread: ' + _pthread_self() + (ENVIRONMENT_IS_PTHREAD?'(pthread)':'') + '\n');
|
|
if (ret === 'timed-out') return -73;
|
|
if (ret === 'not-equal') return -6;
|
|
if (ret === 'ok') return 0;
|
|
throw 'Atomics.wait returned an unexpected value ' + ret;
|
|
} else {
|
|
// Atomics.wait is not available in the main browser thread, so simulate it via busy spinning.
|
|
var loadedVal = Atomics.load(HEAP32, addr >> 2);
|
|
if (val != loadedVal) return -6;
|
|
|
|
var tNow = performance.now();
|
|
var tEnd = tNow + timeout;
|
|
|
|
|
|
// Register globally which address the main thread is simulating to be waiting on. When zero, main thread is not waiting on anything,
|
|
// and on nonzero, the contents of address pointed by __main_thread_futex_wait_address tell which address the main thread is simulating its wait on.
|
|
Atomics.store(HEAP32, __main_thread_futex_wait_address >> 2, addr);
|
|
var ourWaitAddress = addr; // We may recursively re-enter this function while processing queued calls, in which case we'll do a spurious wakeup of the older wait operation.
|
|
while (addr == ourWaitAddress) {
|
|
tNow = performance.now();
|
|
if (tNow > tEnd) {
|
|
return -73;
|
|
}
|
|
_emscripten_main_thread_process_queued_calls(); // We are performing a blocking loop here, so must pump any pthreads if they want to perform operations that are proxied.
|
|
addr = Atomics.load(HEAP32, __main_thread_futex_wait_address >> 2); // Look for a worker thread waking us up.
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
Module["_emscripten_futex_wait"] = _emscripten_futex_wait;
|
|
|
|
|
|
function _emscripten_get_heap_size() {
|
|
return HEAP8.length;
|
|
}
|
|
Module["_emscripten_get_heap_size"] = _emscripten_get_heap_size;
|
|
|
|
|
|
function _emscripten_get_sbrk_ptr() {
|
|
return 10203408;
|
|
}
|
|
Module["_emscripten_get_sbrk_ptr"] = _emscripten_get_sbrk_ptr;
|
|
|
|
function _emscripten_has_threading_support() {
|
|
return typeof SharedArrayBuffer !== 'undefined';
|
|
}
|
|
Module["_emscripten_has_threading_support"] = _emscripten_has_threading_support;
|
|
|
|
function _emscripten_is_main_browser_thread() {
|
|
return __pthread_is_main_browser_thread|0; // Semantically the same as testing "!ENVIRONMENT_IS_WORKER" outside the asm.js scope
|
|
}
|
|
Module["_emscripten_is_main_browser_thread"] = _emscripten_is_main_browser_thread;
|
|
|
|
function _emscripten_is_main_runtime_thread() {
|
|
return __pthread_is_main_runtime_thread|0; // Semantically the same as testing "!ENVIRONMENT_IS_PTHREAD" outside the asm.js scope
|
|
}
|
|
Module["_emscripten_is_main_runtime_thread"] = _emscripten_is_main_runtime_thread;
|
|
|
|
|
|
|
|
|
|
var setjmpId=0;
|
|
Module["setjmpId"] = setjmpId;function _saveSetjmp(env, label, table, size) {
|
|
// Not particularly fast: slow table lookup of setjmpId to label. But setjmp
|
|
// prevents relooping anyhow, so slowness is to be expected. And typical case
|
|
// is 1 setjmp per invocation, or less.
|
|
env = env|0;
|
|
label = label|0;
|
|
table = table|0;
|
|
size = size|0;
|
|
var i = 0;
|
|
setjmpId = (setjmpId+1)|0;
|
|
HEAP32[((env)>>2)]=setjmpId;
|
|
while ((i|0) < (size|0)) {
|
|
if (((HEAP32[(((table)+((i<<3)))>>2)])|0) == 0) {
|
|
HEAP32[(((table)+((i<<3)))>>2)]=setjmpId;
|
|
HEAP32[(((table)+((i<<3)+4))>>2)]=label;
|
|
// prepare next slot
|
|
HEAP32[(((table)+((i<<3)+8))>>2)]=0;
|
|
setTempRet0((size) | 0);
|
|
return table | 0;
|
|
}
|
|
i = i+1|0;
|
|
}
|
|
// grow the table
|
|
size = (size*2)|0;
|
|
table = _realloc(table|0, 8*(size+1|0)|0) | 0;
|
|
table = _saveSetjmp(env|0, label|0, table|0, size|0) | 0;
|
|
setTempRet0((size) | 0);
|
|
return table | 0;
|
|
}
|
|
Module["_saveSetjmp"] = _saveSetjmp;
|
|
|
|
function _testSetjmp(id, table, size) {
|
|
id = id|0;
|
|
table = table|0;
|
|
size = size|0;
|
|
var i = 0, curr = 0;
|
|
while ((i|0) < (size|0)) {
|
|
curr = ((HEAP32[(((table)+((i<<3)))>>2)])|0);
|
|
if ((curr|0) == 0) break;
|
|
if ((curr|0) == (id|0)) {
|
|
return ((HEAP32[(((table)+((i<<3)+4))>>2)])|0);
|
|
}
|
|
i = i+1|0;
|
|
}
|
|
return 0;
|
|
}
|
|
Module["_testSetjmp"] = _testSetjmp;function _longjmp(env, value) {
|
|
_setThrew(env, value || 1);
|
|
throw 'longjmp';
|
|
}
|
|
Module["_longjmp"] = _longjmp;function _emscripten_longjmp(env, value) {
|
|
_longjmp(env, value);
|
|
}
|
|
Module["_emscripten_longjmp"] = _emscripten_longjmp;
|
|
|
|
function _emscripten_memcpy_big(dest, src, num) {
|
|
HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
|
|
}
|
|
Module["_emscripten_memcpy_big"] = _emscripten_memcpy_big;
|
|
|
|
|
|
function _emscripten_proxy_to_main_thread_js(index, sync) {
|
|
// Additional arguments are passed after those two, which are the actual
|
|
// function arguments.
|
|
// The serialization buffer contains the number of call params, and then
|
|
// all the args here.
|
|
// We also pass 'sync' to C separately, since C needs to look at it.
|
|
var numCallArgs = arguments.length - 2;
|
|
// Allocate a buffer, which will be copied by the C code.
|
|
var stack = stackSave();
|
|
// First passed parameter specifies the number of arguments to the function.
|
|
var args = stackAlloc(numCallArgs * 8);
|
|
var b = args >> 3;
|
|
for (var i = 0; i < numCallArgs; i++) {
|
|
HEAPF64[b + i] = arguments[2 + i];
|
|
}
|
|
var ret = _emscripten_run_in_main_runtime_thread_js(index, numCallArgs, args, sync);
|
|
stackRestore(stack);
|
|
return ret;
|
|
}
|
|
Module["_emscripten_proxy_to_main_thread_js"] = _emscripten_proxy_to_main_thread_js;
|
|
|
|
var _emscripten_receive_on_main_thread_js_callArgs=[];
|
|
Module["_emscripten_receive_on_main_thread_js_callArgs"] = _emscripten_receive_on_main_thread_js_callArgs;function _emscripten_receive_on_main_thread_js(index, numCallArgs, args) {
|
|
_emscripten_receive_on_main_thread_js_callArgs.length = numCallArgs;
|
|
var b = args >> 3;
|
|
for (var i = 0; i < numCallArgs; i++) {
|
|
_emscripten_receive_on_main_thread_js_callArgs[i] = HEAPF64[b + i];
|
|
}
|
|
// Proxied JS library funcs are encoded as positive values, and
|
|
// EM_ASMs as negative values (see include_asm_consts)
|
|
var isEmAsmConst = index < 0;
|
|
var func = !isEmAsmConst ? proxiedFunctionTable[index] : ASM_CONSTS[-index - 1];
|
|
if (isEmAsmConst) {
|
|
// EM_ASM arguments are stored in their own buffer in memory, that we need
|
|
// to unpack in order to call. The proxied arguments are the code index,
|
|
// signature pointer, and vararg buffer pointer, in that order.
|
|
var sigPtr = _emscripten_receive_on_main_thread_js_callArgs[1];
|
|
var varargPtr = _emscripten_receive_on_main_thread_js_callArgs[2];
|
|
var constArgs = readAsmConstArgs(sigPtr, varargPtr);
|
|
return func.apply(null, constArgs);
|
|
}
|
|
return func.apply(null, _emscripten_receive_on_main_thread_js_callArgs);
|
|
}
|
|
Module["_emscripten_receive_on_main_thread_js"] = _emscripten_receive_on_main_thread_js;
|
|
|
|
|
|
function abortOnCannotGrowMemory(requestedSize) {
|
|
abort('OOM');
|
|
}
|
|
Module["abortOnCannotGrowMemory"] = abortOnCannotGrowMemory;function _emscripten_resize_heap(requestedSize) {
|
|
abortOnCannotGrowMemory(requestedSize);
|
|
}
|
|
Module["_emscripten_resize_heap"] = _emscripten_resize_heap;
|
|
|
|
|
|
var JSEvents={keyEvent:0,mouseEvent:0,wheelEvent:0,uiEvent:0,focusEvent:0,deviceOrientationEvent:0,deviceMotionEvent:0,fullscreenChangeEvent:0,pointerlockChangeEvent:0,visibilityChangeEvent:0,touchEvent:0,previousFullscreenElement:null,previousScreenX:null,previousScreenY:null,removeEventListenersRegistered:false,removeAllEventListeners:function() {
|
|
for(var i = JSEvents.eventHandlers.length-1; i >= 0; --i) {
|
|
JSEvents._removeHandler(i);
|
|
}
|
|
JSEvents.eventHandlers = [];
|
|
JSEvents.deferredCalls = [];
|
|
},registerRemoveEventListeners:function() {
|
|
if (!JSEvents.removeEventListenersRegistered) {
|
|
__ATEXIT__.push(JSEvents.removeAllEventListeners);
|
|
JSEvents.removeEventListenersRegistered = true;
|
|
}
|
|
},deferredCalls:[],deferCall:function(targetFunction, precedence, argsList) {
|
|
function arraysHaveEqualContent(arrA, arrB) {
|
|
if (arrA.length != arrB.length) return false;
|
|
|
|
for(var i in arrA) {
|
|
if (arrA[i] != arrB[i]) return false;
|
|
}
|
|
return true;
|
|
}
|
|
// Test if the given call was already queued, and if so, don't add it again.
|
|
for(var i in JSEvents.deferredCalls) {
|
|
var call = JSEvents.deferredCalls[i];
|
|
if (call.targetFunction == targetFunction && arraysHaveEqualContent(call.argsList, argsList)) {
|
|
return;
|
|
}
|
|
}
|
|
JSEvents.deferredCalls.push({
|
|
targetFunction: targetFunction,
|
|
precedence: precedence,
|
|
argsList: argsList
|
|
});
|
|
|
|
JSEvents.deferredCalls.sort(function(x,y) { return x.precedence < y.precedence; });
|
|
},removeDeferredCalls:function(targetFunction) {
|
|
for(var i = 0; i < JSEvents.deferredCalls.length; ++i) {
|
|
if (JSEvents.deferredCalls[i].targetFunction == targetFunction) {
|
|
JSEvents.deferredCalls.splice(i, 1);
|
|
--i;
|
|
}
|
|
}
|
|
},canPerformEventHandlerRequests:function() {
|
|
return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls;
|
|
},runDeferredCalls:function() {
|
|
if (!JSEvents.canPerformEventHandlerRequests()) {
|
|
return;
|
|
}
|
|
for(var i = 0; i < JSEvents.deferredCalls.length; ++i) {
|
|
var call = JSEvents.deferredCalls[i];
|
|
JSEvents.deferredCalls.splice(i, 1);
|
|
--i;
|
|
call.targetFunction.apply(this, call.argsList);
|
|
}
|
|
},inEventHandler:0,currentEventHandler:null,eventHandlers:[],isInternetExplorer:function() { return navigator.userAgent.indexOf('MSIE') !== -1 || navigator.appVersion.indexOf('Trident/') > 0; },removeAllHandlersOnTarget:function(target, eventTypeString) {
|
|
for(var i = 0; i < JSEvents.eventHandlers.length; ++i) {
|
|
if (JSEvents.eventHandlers[i].target == target &&
|
|
(!eventTypeString || eventTypeString == JSEvents.eventHandlers[i].eventTypeString)) {
|
|
JSEvents._removeHandler(i--);
|
|
}
|
|
}
|
|
},_removeHandler:function(i) {
|
|
var h = JSEvents.eventHandlers[i];
|
|
h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture);
|
|
JSEvents.eventHandlers.splice(i, 1);
|
|
},registerOrRemoveHandler:function(eventHandler) {
|
|
var jsEventHandler = function jsEventHandler(event) {
|
|
// Increment nesting count for the event handler.
|
|
++JSEvents.inEventHandler;
|
|
JSEvents.currentEventHandler = eventHandler;
|
|
// Process any old deferred calls the user has placed.
|
|
JSEvents.runDeferredCalls();
|
|
// Process the actual event, calls back to user C code handler.
|
|
eventHandler.handlerFunc(event);
|
|
// Process any new deferred calls that were placed right now from this event handler.
|
|
JSEvents.runDeferredCalls();
|
|
// Out of event handler - restore nesting count.
|
|
--JSEvents.inEventHandler;
|
|
};
|
|
|
|
if (eventHandler.callbackfunc) {
|
|
eventHandler.eventListenerFunc = jsEventHandler;
|
|
eventHandler.target.addEventListener(eventHandler.eventTypeString, jsEventHandler, eventHandler.useCapture);
|
|
JSEvents.eventHandlers.push(eventHandler);
|
|
JSEvents.registerRemoveEventListeners();
|
|
} else {
|
|
for(var i = 0; i < JSEvents.eventHandlers.length; ++i) {
|
|
if (JSEvents.eventHandlers[i].target == eventHandler.target
|
|
&& JSEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString) {
|
|
JSEvents._removeHandler(i--);
|
|
}
|
|
}
|
|
}
|
|
},queueEventHandlerOnThread_iiii:function(targetThread, eventHandlerFunc, eventTypeId, eventData, userData) {
|
|
var stackTop = stackSave();
|
|
var varargs = stackAlloc(12);
|
|
HEAP32[((varargs)>>2)]=eventTypeId;
|
|
HEAP32[(((varargs)+(4))>>2)]=eventData;
|
|
HEAP32[(((varargs)+(8))>>2)]=userData;
|
|
_emscripten_async_queue_on_thread_(targetThread, 637534208, eventHandlerFunc, eventData, varargs);
|
|
stackRestore(stackTop);
|
|
},getTargetThreadForEventCallback:function(targetThread) {
|
|
switch(targetThread) {
|
|
case 1: return 0; // The event callback for the current event should be called on the main browser thread. (0 == don't proxy)
|
|
case 2: return PThread.currentProxiedOperationCallerThread; // The event callback for the current event should be backproxied to the the thread that is registering the event.
|
|
default: return targetThread; // The event callback for the current event should be proxied to the given specific thread.
|
|
}
|
|
},getBoundingClientRectOrZeros:function(target) {
|
|
return target.getBoundingClientRect ? target.getBoundingClientRect() : { left: 0, top: 0 };
|
|
},getNodeNameForTarget:function(target) {
|
|
if (!target) return '';
|
|
if (target == window) return '#window';
|
|
if (target == screen) return '#screen';
|
|
return (target && target.nodeName) ? target.nodeName : '';
|
|
},tick:function() {
|
|
if (window['performance'] && window['performance']['now']) return window['performance']['now']();
|
|
else return Date.now();
|
|
},fullscreenEnabled:function() {
|
|
return document.fullscreenEnabled || document.mozFullScreenEnabled || document.webkitFullscreenEnabled || document.msFullscreenEnabled;
|
|
}};
|
|
Module["JSEvents"] = JSEvents;
|
|
|
|
|
|
|
|
|
|
function stringToNewUTF8(jsString) {
|
|
var length = lengthBytesUTF8(jsString)+1;
|
|
var cString = _malloc(length);
|
|
stringToUTF8(jsString, cString, length);
|
|
return cString;
|
|
}
|
|
Module["stringToNewUTF8"] = stringToNewUTF8;function _emscripten_set_offscreencanvas_size_on_target_thread_js(targetThread, targetCanvas, width, height) {
|
|
var stackTop = stackSave();
|
|
var varargs = stackAlloc(12);
|
|
var targetCanvasPtr = 0;
|
|
if (targetCanvas) {
|
|
targetCanvasPtr = stringToNewUTF8(targetCanvas);
|
|
}
|
|
HEAP32[((varargs)>>2)]=targetCanvasPtr;
|
|
HEAP32[(((varargs)+(4))>>2)]=width;
|
|
HEAP32[(((varargs)+(8))>>2)]=height;
|
|
// Note: If we are also a pthread, the call below could theoretically be done synchronously. However if the target pthread is waiting for a mutex from us, then
|
|
// these two threads will deadlock. At the moment, we'd like to consider that this kind of deadlock would be an Emscripten runtime bug, although if
|
|
// emscripten_set_canvas_element_size() was documented to require running an event in the queue of thread that owns the OffscreenCanvas, then that might be ok.
|
|
// (safer this way however)
|
|
_emscripten_async_queue_on_thread_(targetThread, 657457152, 0, targetCanvasPtr /* satellite data */, varargs);
|
|
stackRestore(stackTop);
|
|
}
|
|
Module["_emscripten_set_offscreencanvas_size_on_target_thread_js"] = _emscripten_set_offscreencanvas_size_on_target_thread_js;function _emscripten_set_offscreencanvas_size_on_target_thread(targetThread, targetCanvas, width, height) {
|
|
targetCanvas = targetCanvas ? UTF8ToString(targetCanvas) : '';
|
|
_emscripten_set_offscreencanvas_size_on_target_thread_js(targetThread, targetCanvas, width, height);
|
|
}
|
|
Module["_emscripten_set_offscreencanvas_size_on_target_thread"] = _emscripten_set_offscreencanvas_size_on_target_thread;
|
|
|
|
|
|
|
|
var __specialEventTargets=[0, typeof document !== 'undefined' ? document : 0, typeof window !== 'undefined' ? window : 0];
|
|
Module["__specialEventTargets"] = __specialEventTargets;function __findEventTarget(target) {
|
|
try {
|
|
// The sensible "default" target varies between events, but use window as the default
|
|
// since DOM events mostly can default to that. Specific callback registrations
|
|
// override their own defaults.
|
|
if (!target) return window;
|
|
if (typeof target === "number") target = __specialEventTargets[target] || UTF8ToString(target);
|
|
if (target === '#window') return window;
|
|
else if (target === '#document') return document;
|
|
else if (target === '#screen') return screen;
|
|
else if (target === '#canvas') return Module['canvas'];
|
|
return (typeof target === 'string') ? document.getElementById(target) : target;
|
|
} catch(e) {
|
|
// In Web Workers, some objects above, such as '#document' do not exist. Gracefully
|
|
// return null for them.
|
|
return null;
|
|
}
|
|
}
|
|
Module["__findEventTarget"] = __findEventTarget;function __findCanvasEventTarget(target) {
|
|
if (typeof target === 'number') target = UTF8ToString(target);
|
|
if (!target || target === '#canvas') {
|
|
if (typeof GL !== 'undefined' && GL.offscreenCanvases['canvas']) return GL.offscreenCanvases['canvas']; // TODO: Remove this line, target '#canvas' should refer only to Module['canvas'], not to GL.offscreenCanvases['canvas'] - but need stricter tests to be able to remove this line.
|
|
return Module['canvas'];
|
|
}
|
|
if (typeof GL !== 'undefined' && GL.offscreenCanvases[target]) return GL.offscreenCanvases[target];
|
|
return __findEventTarget(target);
|
|
}
|
|
Module["__findCanvasEventTarget"] = __findCanvasEventTarget;function _emscripten_set_canvas_element_size_calling_thread(target, width, height) {
|
|
var canvas = __findCanvasEventTarget(target);
|
|
if (!canvas) return -4;
|
|
|
|
if (canvas.canvasSharedPtr) {
|
|
// N.B. We hold the canvasSharedPtr info structure as the authoritative source for specifying the size of a canvas
|
|
// since the actual canvas size changes are asynchronous if the canvas is owned by an OffscreenCanvas on another thread.
|
|
// Therefore when setting the size, eagerly set the size of the canvas on the calling thread here, though this thread
|
|
// might not be the one that actually ends up specifying the size, but the actual size change may be dispatched
|
|
// as an asynchronous event below.
|
|
HEAP32[((canvas.canvasSharedPtr)>>2)]=width;
|
|
HEAP32[(((canvas.canvasSharedPtr)+(4))>>2)]=height;
|
|
}
|
|
|
|
if (canvas.offscreenCanvas || !canvas.controlTransferredOffscreen) {
|
|
if (canvas.offscreenCanvas) canvas = canvas.offscreenCanvas;
|
|
var autoResizeViewport = false;
|
|
if (canvas.GLctxObject && canvas.GLctxObject.GLctx) {
|
|
var prevViewport = canvas.GLctxObject.GLctx.getParameter(canvas.GLctxObject.GLctx.VIEWPORT);
|
|
// TODO: Perhaps autoResizeViewport should only be true if FBO 0 is currently active?
|
|
autoResizeViewport = (prevViewport[0] === 0 && prevViewport[1] === 0 && prevViewport[2] === canvas.width && prevViewport[3] === canvas.height);
|
|
}
|
|
canvas.width = width;
|
|
canvas.height = height;
|
|
if (autoResizeViewport) {
|
|
// TODO: Add -s CANVAS_RESIZE_SETS_GL_VIEWPORT=0/1 option (default=1). This is commonly done and several graphics engines depend on this,
|
|
// but this can be quite disruptive.
|
|
canvas.GLctxObject.GLctx.viewport(0, 0, width, height);
|
|
}
|
|
} else if (canvas.canvasSharedPtr) {
|
|
var targetThread = HEAP32[(((canvas.canvasSharedPtr)+(8))>>2)];
|
|
_emscripten_set_offscreencanvas_size_on_target_thread(targetThread, target, width, height);
|
|
return 1; // This will have to be done asynchronously
|
|
} else {
|
|
return -4;
|
|
}
|
|
return 0;
|
|
}
|
|
Module["_emscripten_set_canvas_element_size_calling_thread"] = _emscripten_set_canvas_element_size_calling_thread;
|
|
|
|
function _emscripten_set_canvas_element_size_main_thread(target, width, height) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(17, 1, target, width, height);
|
|
return _emscripten_set_canvas_element_size_calling_thread(target, width, height); }
|
|
|
|
Module["_emscripten_set_canvas_element_size_main_thread"] = _emscripten_set_canvas_element_size_main_thread;function _emscripten_set_canvas_element_size(target, width, height) {
|
|
var canvas = __findCanvasEventTarget(target);
|
|
if (canvas) {
|
|
return _emscripten_set_canvas_element_size_calling_thread(target, width, height);
|
|
} else {
|
|
return _emscripten_set_canvas_element_size_main_thread(target, width, height);
|
|
}
|
|
}
|
|
Module["_emscripten_set_canvas_element_size"] = _emscripten_set_canvas_element_size;
|
|
|
|
|
|
function _emscripten_set_current_thread_status_js(newStatus) {
|
|
}
|
|
Module["_emscripten_set_current_thread_status_js"] = _emscripten_set_current_thread_status_js;function _emscripten_set_current_thread_status(newStatus) {
|
|
newStatus = newStatus|0;
|
|
}
|
|
Module["_emscripten_set_current_thread_status"] = _emscripten_set_current_thread_status;
|
|
|
|
|
|
function _emscripten_set_thread_name_js(threadId, name) {
|
|
}
|
|
Module["_emscripten_set_thread_name_js"] = _emscripten_set_thread_name_js;function _emscripten_set_thread_name(threadId, name) {
|
|
threadId = threadId|0;
|
|
name = name|0;
|
|
}
|
|
Module["_emscripten_set_thread_name"] = _emscripten_set_thread_name;
|
|
|
|
function _emscripten_syscall(which, varargs) {
|
|
switch (which) {
|
|
case 10: return ___syscall10(which, varargs);
|
|
case 12: return ___syscall12(which, varargs);
|
|
case 183: return ___syscall183(which, varargs);
|
|
case 195: return ___syscall195(which, varargs);
|
|
case 196: return ___syscall196(which, varargs);
|
|
case 220: return ___syscall220(which, varargs);
|
|
case 221: return ___syscall221(which, varargs);
|
|
case 3: return ___syscall3(which, varargs);
|
|
case 39: return ___syscall39(which, varargs);
|
|
case 4: return ___syscall4(which, varargs);
|
|
case 40: return ___syscall40(which, varargs);
|
|
case 5: return ___syscall5(which, varargs);
|
|
case 54: return ___syscall54(which, varargs);
|
|
case 85: return ___syscall85(which, varargs);
|
|
case 91: return ___syscall91(which, varargs);
|
|
default: throw "surprising proxied syscall: " + which;
|
|
}
|
|
}
|
|
Module["_emscripten_syscall"] = _emscripten_syscall;
|
|
|
|
|
|
|
|
var __emscripten_webgl_power_preferences=['default', 'low-power', 'high-performance'];
|
|
Module["__emscripten_webgl_power_preferences"] = __emscripten_webgl_power_preferences;
|
|
|
|
var GL={counter:1,lastError:0,buffers:[],mappedBuffers:{},programs:[],framebuffers:[],renderbuffers:[],textures:[],uniforms:[],shaders:[],vaos:[],contexts:{},currentContext:null,offscreenCanvases:{},timerQueriesEXT:[],programInfos:{},stringCache:{},unpackAlignment:4,init:function() {
|
|
GL.miniTempBuffer = new Float32Array(GL.MINI_TEMP_BUFFER_SIZE);
|
|
for (var i = 0; i < GL.MINI_TEMP_BUFFER_SIZE; i++) {
|
|
GL.miniTempBufferViews[i] = GL.miniTempBuffer.subarray(0, i+1);
|
|
}
|
|
},recordError:function recordError(errorCode) {
|
|
if (!GL.lastError) {
|
|
GL.lastError = errorCode;
|
|
}
|
|
},getNewId:function(table) {
|
|
var ret = GL.counter++;
|
|
for (var i = table.length; i < ret; i++) {
|
|
table[i] = null;
|
|
}
|
|
return ret;
|
|
},MINI_TEMP_BUFFER_SIZE:256,miniTempBuffer:null,miniTempBufferViews:[0],getSource:function(shader, count, string, length) {
|
|
var source = '';
|
|
for (var i = 0; i < count; ++i) {
|
|
var len = length ? HEAP32[(((length)+(i*4))>>2)] : -1;
|
|
source += UTF8ToString(HEAP32[(((string)+(i*4))>>2)], len < 0 ? undefined : len);
|
|
}
|
|
return source;
|
|
},createContext:function(canvas, webGLContextAttributes) {
|
|
|
|
|
|
|
|
|
|
var ctx =
|
|
(canvas.getContext("webgl", webGLContextAttributes) || canvas.getContext("experimental-webgl", webGLContextAttributes));
|
|
|
|
|
|
if (!ctx) return 0;
|
|
|
|
var handle = GL.registerContext(ctx, webGLContextAttributes);
|
|
|
|
|
|
|
|
return handle;
|
|
},registerContext:function(ctx, webGLContextAttributes) {
|
|
var handle = _malloc(8); // Make space on the heap to store GL context attributes that need to be accessible as shared between threads.
|
|
HEAP32[(((handle)+(4))>>2)]=_pthread_self(); // the thread pointer of the thread that owns the control of the context
|
|
var context = {
|
|
handle: handle,
|
|
attributes: webGLContextAttributes,
|
|
version: webGLContextAttributes.majorVersion,
|
|
GLctx: ctx
|
|
};
|
|
|
|
|
|
|
|
// Store the created context object so that we can access the context given a canvas without having to pass the parameters again.
|
|
if (ctx.canvas) ctx.canvas.GLctxObject = context;
|
|
GL.contexts[handle] = context;
|
|
if (typeof webGLContextAttributes.enableExtensionsByDefault === 'undefined' || webGLContextAttributes.enableExtensionsByDefault) {
|
|
GL.initExtensions(context);
|
|
}
|
|
|
|
|
|
|
|
|
|
return handle;
|
|
},makeContextCurrent:function(contextHandle) {
|
|
|
|
GL.currentContext = GL.contexts[contextHandle]; // Active Emscripten GL layer context object.
|
|
Module.ctx = GLctx = GL.currentContext && GL.currentContext.GLctx; // Active WebGL context object.
|
|
return !(contextHandle && !GLctx);
|
|
},getContext:function(contextHandle) {
|
|
return GL.contexts[contextHandle];
|
|
},deleteContext:function(contextHandle) {
|
|
if (GL.currentContext === GL.contexts[contextHandle]) GL.currentContext = null;
|
|
if (typeof JSEvents === 'object') JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas); // Release all JS event handlers on the DOM element that the GL context is associated with since the context is now deleted.
|
|
if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas) GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined; // Make sure the canvas object no longer refers to the context object so there are no GC surprises.
|
|
_free(GL.contexts[contextHandle]);
|
|
GL.contexts[contextHandle] = null;
|
|
},acquireInstancedArraysExtension:function(ctx) {
|
|
// Extension available in WebGL 1 from Firefox 26 and Google Chrome 30 onwards. Core feature in WebGL 2.
|
|
var ext = ctx.getExtension('ANGLE_instanced_arrays');
|
|
if (ext) {
|
|
ctx['vertexAttribDivisor'] = function(index, divisor) { ext['vertexAttribDivisorANGLE'](index, divisor); };
|
|
ctx['drawArraysInstanced'] = function(mode, first, count, primcount) { ext['drawArraysInstancedANGLE'](mode, first, count, primcount); };
|
|
ctx['drawElementsInstanced'] = function(mode, count, type, indices, primcount) { ext['drawElementsInstancedANGLE'](mode, count, type, indices, primcount); };
|
|
}
|
|
},acquireVertexArrayObjectExtension:function(ctx) {
|
|
// Extension available in WebGL 1 from Firefox 25 and WebKit 536.28/desktop Safari 6.0.3 onwards. Core feature in WebGL 2.
|
|
var ext = ctx.getExtension('OES_vertex_array_object');
|
|
if (ext) {
|
|
ctx['createVertexArray'] = function() { return ext['createVertexArrayOES'](); };
|
|
ctx['deleteVertexArray'] = function(vao) { ext['deleteVertexArrayOES'](vao); };
|
|
ctx['bindVertexArray'] = function(vao) { ext['bindVertexArrayOES'](vao); };
|
|
ctx['isVertexArray'] = function(vao) { return ext['isVertexArrayOES'](vao); };
|
|
}
|
|
},acquireDrawBuffersExtension:function(ctx) {
|
|
// Extension available in WebGL 1 from Firefox 28 onwards. Core feature in WebGL 2.
|
|
var ext = ctx.getExtension('WEBGL_draw_buffers');
|
|
if (ext) {
|
|
ctx['drawBuffers'] = function(n, bufs) { ext['drawBuffersWEBGL'](n, bufs); };
|
|
}
|
|
},initExtensions:function(context) {
|
|
// If this function is called without a specific context object, init the extensions of the currently active context.
|
|
if (!context) context = GL.currentContext;
|
|
|
|
if (context.initExtensionsDone) return;
|
|
context.initExtensionsDone = true;
|
|
|
|
var GLctx = context.GLctx;
|
|
|
|
// Detect the presence of a few extensions manually, this GL interop layer itself will need to know if they exist.
|
|
|
|
if (context.version < 2) {
|
|
GL.acquireInstancedArraysExtension(GLctx);
|
|
GL.acquireVertexArrayObjectExtension(GLctx);
|
|
GL.acquireDrawBuffersExtension(GLctx);
|
|
}
|
|
|
|
GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query");
|
|
|
|
// These are the 'safe' feature-enabling extensions that don't add any performance impact related to e.g. debugging, and
|
|
// should be enabled by default so that client GLES2/GL code will not need to go through extra hoops to get its stuff working.
|
|
// As new extensions are ratified at http://www.khronos.org/registry/webgl/extensions/ , feel free to add your new extensions
|
|
// here, as long as they don't produce a performance impact for users that might not be using those extensions.
|
|
// E.g. debugging-related extensions should probably be off by default.
|
|
var automaticallyEnabledExtensions = [ // Khronos ratified WebGL extensions ordered by number (no debug extensions):
|
|
"OES_texture_float", "OES_texture_half_float", "OES_standard_derivatives",
|
|
"OES_vertex_array_object", "WEBGL_compressed_texture_s3tc", "WEBGL_depth_texture",
|
|
"OES_element_index_uint", "EXT_texture_filter_anisotropic", "EXT_frag_depth",
|
|
"WEBGL_draw_buffers", "ANGLE_instanced_arrays", "OES_texture_float_linear",
|
|
"OES_texture_half_float_linear", "EXT_blend_minmax", "EXT_shader_texture_lod",
|
|
// Community approved WebGL extensions ordered by number:
|
|
"WEBGL_compressed_texture_pvrtc", "EXT_color_buffer_half_float", "WEBGL_color_buffer_float",
|
|
"EXT_sRGB", "WEBGL_compressed_texture_etc1", "EXT_disjoint_timer_query",
|
|
"WEBGL_compressed_texture_etc", "WEBGL_compressed_texture_astc", "EXT_color_buffer_float",
|
|
"WEBGL_compressed_texture_s3tc_srgb", "EXT_disjoint_timer_query_webgl2",
|
|
// Old style prefixed forms of extensions (but still currently used on e.g. iPhone Xs as
|
|
// tested on iOS 12.4.1):
|
|
"WEBKIT_WEBGL_compressed_texture_pvrtc"];
|
|
|
|
function shouldEnableAutomatically(extension) {
|
|
var ret = false;
|
|
automaticallyEnabledExtensions.forEach(function(include) {
|
|
if (extension.indexOf(include) != -1) {
|
|
ret = true;
|
|
}
|
|
});
|
|
return ret;
|
|
}
|
|
|
|
var exts = GLctx.getSupportedExtensions() || []; // .getSupportedExtensions() can return null if context is lost, so coerce to empty array.
|
|
exts.forEach(function(ext) {
|
|
if (automaticallyEnabledExtensions.indexOf(ext) != -1) {
|
|
GLctx.getExtension(ext); // Calling .getExtension enables that extension permanently, no need to store the return value to be enabled.
|
|
}
|
|
});
|
|
},populateUniformTable:function(program) {
|
|
var p = GL.programs[program];
|
|
var ptable = GL.programInfos[program] = {
|
|
uniforms: {},
|
|
maxUniformLength: 0, // This is eagerly computed below, since we already enumerate all uniforms anyway.
|
|
maxAttributeLength: -1, // This is lazily computed and cached, computed when/if first asked, "-1" meaning not computed yet.
|
|
maxUniformBlockNameLength: -1 // Lazily computed as well
|
|
};
|
|
|
|
var utable = ptable.uniforms;
|
|
// A program's uniform table maps the string name of an uniform to an integer location of that uniform.
|
|
// The global GL.uniforms map maps integer locations to WebGLUniformLocations.
|
|
var numUniforms = GLctx.getProgramParameter(p, 0x8B86/*GL_ACTIVE_UNIFORMS*/);
|
|
for (var i = 0; i < numUniforms; ++i) {
|
|
var u = GLctx.getActiveUniform(p, i);
|
|
|
|
var name = u.name;
|
|
ptable.maxUniformLength = Math.max(ptable.maxUniformLength, name.length+1);
|
|
|
|
// If we are dealing with an array, e.g. vec4 foo[3], strip off the array index part to canonicalize that "foo", "foo[]",
|
|
// and "foo[0]" will mean the same. Loop below will populate foo[1] and foo[2].
|
|
if (name.slice(-1) == ']') {
|
|
name = name.slice(0, name.lastIndexOf('['));
|
|
}
|
|
|
|
// Optimize memory usage slightly: If we have an array of uniforms, e.g. 'vec3 colors[3];', then
|
|
// only store the string 'colors' in utable, and 'colors[0]', 'colors[1]' and 'colors[2]' will be parsed as 'colors'+i.
|
|
// Note that for the GL.uniforms table, we still need to fetch the all WebGLUniformLocations for all the indices.
|
|
var loc = GLctx.getUniformLocation(p, name);
|
|
if (loc) {
|
|
var id = GL.getNewId(GL.uniforms);
|
|
utable[name] = [u.size, id];
|
|
GL.uniforms[id] = loc;
|
|
|
|
for (var j = 1; j < u.size; ++j) {
|
|
var n = name + '['+j+']';
|
|
loc = GLctx.getUniformLocation(p, n);
|
|
id = GL.getNewId(GL.uniforms);
|
|
|
|
GL.uniforms[id] = loc;
|
|
}
|
|
}
|
|
}
|
|
}};
|
|
Module["GL"] = GL;function _emscripten_webgl_do_create_context(target, attributes) {
|
|
var contextAttributes = {};
|
|
var a = attributes >> 2;
|
|
contextAttributes['alpha'] = !!HEAP32[a + (0>>2)];
|
|
contextAttributes['depth'] = !!HEAP32[a + (4>>2)];
|
|
contextAttributes['stencil'] = !!HEAP32[a + (8>>2)];
|
|
contextAttributes['antialias'] = !!HEAP32[a + (12>>2)];
|
|
contextAttributes['premultipliedAlpha'] = !!HEAP32[a + (16>>2)];
|
|
contextAttributes['preserveDrawingBuffer'] = !!HEAP32[a + (20>>2)];
|
|
var powerPreference = HEAP32[a + (24>>2)];
|
|
contextAttributes['powerPreference'] = __emscripten_webgl_power_preferences[powerPreference];
|
|
contextAttributes['failIfMajorPerformanceCaveat'] = !!HEAP32[a + (28>>2)];
|
|
contextAttributes.majorVersion = HEAP32[a + (32>>2)];
|
|
contextAttributes.minorVersion = HEAP32[a + (36>>2)];
|
|
contextAttributes.enableExtensionsByDefault = HEAP32[a + (40>>2)];
|
|
contextAttributes.explicitSwapControl = HEAP32[a + (44>>2)];
|
|
contextAttributes.proxyContextToMainThread = HEAP32[a + (48>>2)];
|
|
contextAttributes.renderViaOffscreenBackBuffer = HEAP32[a + (52>>2)];
|
|
|
|
var canvas = __findCanvasEventTarget(target);
|
|
|
|
|
|
|
|
if (!canvas) {
|
|
return 0;
|
|
}
|
|
|
|
if (contextAttributes.explicitSwapControl) {
|
|
return 0;
|
|
}
|
|
|
|
|
|
var contextHandle = GL.createContext(canvas, contextAttributes);
|
|
return contextHandle;
|
|
}
|
|
Module["_emscripten_webgl_do_create_context"] = _emscripten_webgl_do_create_context;function _emscripten_webgl_create_context(a0,a1
|
|
) {
|
|
return _emscripten_webgl_do_create_context(a0,a1);
|
|
}
|
|
Module["_emscripten_webgl_create_context"] = _emscripten_webgl_create_context;
|
|
|
|
|
|
|
|
var ENV={};
|
|
Module["ENV"] = ENV;function _emscripten_get_environ() {
|
|
if (!_emscripten_get_environ.strings) {
|
|
// Default values.
|
|
var env = {
|
|
'USER': 'web_user',
|
|
'LOGNAME': 'web_user',
|
|
'PATH': '/',
|
|
'PWD': '/',
|
|
'HOME': '/home/web_user',
|
|
// Browser language detection #8751
|
|
'LANG': ((typeof navigator === 'object' && navigator.languages && navigator.languages[0]) || 'C').replace('-', '_') + '.UTF-8',
|
|
'_': thisProgram
|
|
};
|
|
// Apply the user-provided values, if any.
|
|
for (var x in ENV) {
|
|
env[x] = ENV[x];
|
|
}
|
|
var strings = [];
|
|
for (var x in env) {
|
|
strings.push(x + '=' + env[x]);
|
|
}
|
|
_emscripten_get_environ.strings = strings;
|
|
}
|
|
return _emscripten_get_environ.strings;
|
|
}
|
|
Module["_emscripten_get_environ"] = _emscripten_get_environ;function _environ_get(__environ, environ_buf) {
|
|
var strings = _emscripten_get_environ();
|
|
var bufSize = 0;
|
|
strings.forEach(function(string, i) {
|
|
var ptr = environ_buf + bufSize;
|
|
HEAP32[(((__environ)+(i * 4))>>2)]=ptr;
|
|
writeAsciiToMemory(string, ptr);
|
|
bufSize += string.length + 1;
|
|
});
|
|
return 0;
|
|
}
|
|
Module["_environ_get"] = _environ_get;
|
|
|
|
function _environ_sizes_get(penviron_count, penviron_buf_size) {
|
|
var strings = _emscripten_get_environ();
|
|
HEAP32[((penviron_count)>>2)]=strings.length;
|
|
var bufSize = 0;
|
|
strings.forEach(function(string) {
|
|
bufSize += string.length + 1;
|
|
});
|
|
HEAP32[((penviron_buf_size)>>2)]=bufSize;
|
|
return 0;
|
|
}
|
|
Module["_environ_sizes_get"] = _environ_sizes_get;
|
|
|
|
function _exit(status) {
|
|
// void _exit(int status);
|
|
// http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html
|
|
exit(status);
|
|
}
|
|
Module["_exit"] = _exit;
|
|
|
|
function _fd_close(fd) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(18, 1, fd);
|
|
try {
|
|
|
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
|
FS.close(stream);
|
|
return 0;
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return e.errno;
|
|
}
|
|
}
|
|
|
|
Module["_fd_close"] = _fd_close;
|
|
|
|
function _fd_read(fd, iov, iovcnt, pnum) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(19, 1, fd, iov, iovcnt, pnum);
|
|
try {
|
|
|
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
|
var num = SYSCALLS.doReadv(stream, iov, iovcnt);
|
|
HEAP32[((pnum)>>2)]=num
|
|
return 0;
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return e.errno;
|
|
}
|
|
}
|
|
|
|
Module["_fd_read"] = _fd_read;
|
|
|
|
function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(20, 1, fd, offset_low, offset_high, whence, newOffset);
|
|
try {
|
|
|
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
|
var HIGH_OFFSET = 0x100000000; // 2^32
|
|
// use an unsigned operator on low and shift high by 32-bits
|
|
var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0);
|
|
|
|
var DOUBLE_LIMIT = 0x20000000000000; // 2^53
|
|
// we also check for equality since DOUBLE_LIMIT + 1 == DOUBLE_LIMIT
|
|
if (offset <= -DOUBLE_LIMIT || offset >= DOUBLE_LIMIT) {
|
|
return -61;
|
|
}
|
|
|
|
FS.llseek(stream, offset, whence);
|
|
(tempI64 = [stream.position>>>0,(tempDouble=stream.position,(+(Math_abs(tempDouble))) >= 1.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[((newOffset)>>2)]=tempI64[0],HEAP32[(((newOffset)+(4))>>2)]=tempI64[1]);
|
|
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;
|
|
}
|
|
}
|
|
|
|
Module["_fd_seek"] = _fd_seek;
|
|
|
|
function _fd_write(fd, iov, iovcnt, pnum) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(21, 1, fd, iov, iovcnt, pnum);
|
|
try {
|
|
|
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
|
var num = SYSCALLS.doWritev(stream, iov, iovcnt);
|
|
HEAP32[((pnum)>>2)]=num
|
|
return 0;
|
|
} catch (e) {
|
|
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
|
|
return e.errno;
|
|
}
|
|
}
|
|
|
|
Module["_fd_write"] = _fd_write;
|
|
|
|
function _getTempRet0() {
|
|
return (getTempRet0() | 0);
|
|
}
|
|
Module["_getTempRet0"] = _getTempRet0;
|
|
|
|
function _gettimeofday(ptr) {
|
|
var now = Date.now();
|
|
HEAP32[((ptr)>>2)]=(now/1000)|0; // seconds
|
|
HEAP32[(((ptr)+(4))>>2)]=((now % 1000)*1000)|0; // microseconds
|
|
return 0;
|
|
}
|
|
Module["_gettimeofday"] = _gettimeofday;
|
|
|
|
|
|
var ___tm_current=10203424;
|
|
Module["___tm_current"] = ___tm_current;
|
|
|
|
|
|
var ___tm_timezone=(stringToUTF8("GMT", 10203472, 4), 10203472);
|
|
Module["___tm_timezone"] = ___tm_timezone;function _gmtime_r(time, tmPtr) {
|
|
var date = new Date(HEAP32[((time)>>2)]*1000);
|
|
HEAP32[((tmPtr)>>2)]=date.getUTCSeconds();
|
|
HEAP32[(((tmPtr)+(4))>>2)]=date.getUTCMinutes();
|
|
HEAP32[(((tmPtr)+(8))>>2)]=date.getUTCHours();
|
|
HEAP32[(((tmPtr)+(12))>>2)]=date.getUTCDate();
|
|
HEAP32[(((tmPtr)+(16))>>2)]=date.getUTCMonth();
|
|
HEAP32[(((tmPtr)+(20))>>2)]=date.getUTCFullYear()-1900;
|
|
HEAP32[(((tmPtr)+(24))>>2)]=date.getUTCDay();
|
|
HEAP32[(((tmPtr)+(36))>>2)]=0;
|
|
HEAP32[(((tmPtr)+(32))>>2)]=0;
|
|
var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
|
|
var yday = ((date.getTime() - start) / (1000 * 60 * 60 * 24))|0;
|
|
HEAP32[(((tmPtr)+(28))>>2)]=yday;
|
|
HEAP32[(((tmPtr)+(40))>>2)]=___tm_timezone;
|
|
|
|
return tmPtr;
|
|
}
|
|
Module["_gmtime_r"] = _gmtime_r;function _gmtime(time) {
|
|
return _gmtime_r(time, ___tm_current);
|
|
}
|
|
Module["_gmtime"] = _gmtime;
|
|
|
|
|
|
function _memcpy(dest, src, num) {
|
|
dest = dest|0; src = src|0; num = num|0;
|
|
var ret = 0;
|
|
var aligned_dest_end = 0;
|
|
var block_aligned_dest_end = 0;
|
|
var dest_end = 0;
|
|
// Test against a benchmarked cutoff limit for when HEAPU8.set() becomes faster to use.
|
|
if ((num|0) >= 8192) {
|
|
_emscripten_memcpy_big(dest|0, src|0, num|0)|0;
|
|
return dest|0;
|
|
}
|
|
|
|
ret = dest|0;
|
|
dest_end = (dest + num)|0;
|
|
if ((dest&3) == (src&3)) {
|
|
// The initial unaligned < 4-byte front.
|
|
while (dest & 3) {
|
|
if ((num|0) == 0) return ret|0;
|
|
HEAP8[((dest)>>0)]=((HEAP8[((src)>>0)])|0);
|
|
dest = (dest+1)|0;
|
|
src = (src+1)|0;
|
|
num = (num-1)|0;
|
|
}
|
|
aligned_dest_end = (dest_end & -4)|0;
|
|
block_aligned_dest_end = (aligned_dest_end - 64)|0;
|
|
while ((dest|0) <= (block_aligned_dest_end|0) ) {
|
|
HEAP32[((dest)>>2)]=((HEAP32[((src)>>2)])|0);
|
|
HEAP32[(((dest)+(4))>>2)]=((HEAP32[(((src)+(4))>>2)])|0);
|
|
HEAP32[(((dest)+(8))>>2)]=((HEAP32[(((src)+(8))>>2)])|0);
|
|
HEAP32[(((dest)+(12))>>2)]=((HEAP32[(((src)+(12))>>2)])|0);
|
|
HEAP32[(((dest)+(16))>>2)]=((HEAP32[(((src)+(16))>>2)])|0);
|
|
HEAP32[(((dest)+(20))>>2)]=((HEAP32[(((src)+(20))>>2)])|0);
|
|
HEAP32[(((dest)+(24))>>2)]=((HEAP32[(((src)+(24))>>2)])|0);
|
|
HEAP32[(((dest)+(28))>>2)]=((HEAP32[(((src)+(28))>>2)])|0);
|
|
HEAP32[(((dest)+(32))>>2)]=((HEAP32[(((src)+(32))>>2)])|0);
|
|
HEAP32[(((dest)+(36))>>2)]=((HEAP32[(((src)+(36))>>2)])|0);
|
|
HEAP32[(((dest)+(40))>>2)]=((HEAP32[(((src)+(40))>>2)])|0);
|
|
HEAP32[(((dest)+(44))>>2)]=((HEAP32[(((src)+(44))>>2)])|0);
|
|
HEAP32[(((dest)+(48))>>2)]=((HEAP32[(((src)+(48))>>2)])|0);
|
|
HEAP32[(((dest)+(52))>>2)]=((HEAP32[(((src)+(52))>>2)])|0);
|
|
HEAP32[(((dest)+(56))>>2)]=((HEAP32[(((src)+(56))>>2)])|0);
|
|
HEAP32[(((dest)+(60))>>2)]=((HEAP32[(((src)+(60))>>2)])|0);
|
|
dest = (dest+64)|0;
|
|
src = (src+64)|0;
|
|
}
|
|
while ((dest|0) < (aligned_dest_end|0) ) {
|
|
HEAP32[((dest)>>2)]=((HEAP32[((src)>>2)])|0);
|
|
dest = (dest+4)|0;
|
|
src = (src+4)|0;
|
|
}
|
|
} else {
|
|
// In the unaligned copy case, unroll a bit as well.
|
|
aligned_dest_end = (dest_end - 4)|0;
|
|
while ((dest|0) < (aligned_dest_end|0) ) {
|
|
HEAP8[((dest)>>0)]=((HEAP8[((src)>>0)])|0);
|
|
HEAP8[(((dest)+(1))>>0)]=((HEAP8[(((src)+(1))>>0)])|0);
|
|
HEAP8[(((dest)+(2))>>0)]=((HEAP8[(((src)+(2))>>0)])|0);
|
|
HEAP8[(((dest)+(3))>>0)]=((HEAP8[(((src)+(3))>>0)])|0);
|
|
dest = (dest+4)|0;
|
|
src = (src+4)|0;
|
|
}
|
|
}
|
|
// The remaining unaligned < 4 byte tail.
|
|
while ((dest|0) < (dest_end|0)) {
|
|
HEAP8[((dest)>>0)]=((HEAP8[((src)>>0)])|0);
|
|
dest = (dest+1)|0;
|
|
src = (src+1)|0;
|
|
}
|
|
return ret|0;
|
|
}
|
|
Module["_memcpy"] = _memcpy;
|
|
|
|
function _memset(ptr, value, num) {
|
|
ptr = ptr|0; value = value|0; num = num|0;
|
|
var end = 0, aligned_end = 0, block_aligned_end = 0, value4 = 0;
|
|
end = (ptr + num)|0;
|
|
|
|
value = value & 0xff;
|
|
if ((num|0) >= 67 /* 64 bytes for an unrolled loop + 3 bytes for unaligned head*/) {
|
|
while ((ptr&3) != 0) {
|
|
HEAP8[((ptr)>>0)]=value;
|
|
ptr = (ptr+1)|0;
|
|
}
|
|
|
|
aligned_end = (end & -4)|0;
|
|
value4 = value | (value << 8) | (value << 16) | (value << 24);
|
|
|
|
block_aligned_end = (aligned_end - 64)|0;
|
|
|
|
while((ptr|0) <= (block_aligned_end|0)) {
|
|
HEAP32[((ptr)>>2)]=value4;
|
|
HEAP32[(((ptr)+(4))>>2)]=value4;
|
|
HEAP32[(((ptr)+(8))>>2)]=value4;
|
|
HEAP32[(((ptr)+(12))>>2)]=value4;
|
|
HEAP32[(((ptr)+(16))>>2)]=value4;
|
|
HEAP32[(((ptr)+(20))>>2)]=value4;
|
|
HEAP32[(((ptr)+(24))>>2)]=value4;
|
|
HEAP32[(((ptr)+(28))>>2)]=value4;
|
|
HEAP32[(((ptr)+(32))>>2)]=value4;
|
|
HEAP32[(((ptr)+(36))>>2)]=value4;
|
|
HEAP32[(((ptr)+(40))>>2)]=value4;
|
|
HEAP32[(((ptr)+(44))>>2)]=value4;
|
|
HEAP32[(((ptr)+(48))>>2)]=value4;
|
|
HEAP32[(((ptr)+(52))>>2)]=value4;
|
|
HEAP32[(((ptr)+(56))>>2)]=value4;
|
|
HEAP32[(((ptr)+(60))>>2)]=value4;
|
|
ptr = (ptr + 64)|0;
|
|
}
|
|
|
|
while ((ptr|0) < (aligned_end|0) ) {
|
|
HEAP32[((ptr)>>2)]=value4;
|
|
ptr = (ptr+4)|0;
|
|
}
|
|
}
|
|
// The remaining bytes.
|
|
while ((ptr|0) < (end|0)) {
|
|
HEAP8[((ptr)>>0)]=value;
|
|
ptr = (ptr+1)|0;
|
|
}
|
|
return (end-num)|0;
|
|
}
|
|
Module["_memset"] = _memset;
|
|
|
|
|
|
function _tzset() {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(22, 1);
|
|
|
|
// TODO: Use (malleable) environment variables instead of system settings.
|
|
if (_tzset.called) return;
|
|
_tzset.called = true;
|
|
|
|
// timezone is specified as seconds west of UTC ("The external variable
|
|
// `timezone` shall be set to the difference, in seconds, between
|
|
// Coordinated Universal Time (UTC) and local standard time."), the same
|
|
// as returned by getTimezoneOffset().
|
|
// See http://pubs.opengroup.org/onlinepubs/009695399/functions/tzset.html
|
|
HEAP32[((__get_timezone())>>2)]=(new Date()).getTimezoneOffset() * 60;
|
|
|
|
var currentYear = new Date().getFullYear();
|
|
var winter = new Date(currentYear, 0, 1);
|
|
var summer = new Date(currentYear, 6, 1);
|
|
HEAP32[((__get_daylight())>>2)]=Number(winter.getTimezoneOffset() != summer.getTimezoneOffset());
|
|
|
|
function extractZone(date) {
|
|
var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/);
|
|
return match ? match[1] : "GMT";
|
|
};
|
|
var winterName = extractZone(winter);
|
|
var summerName = extractZone(summer);
|
|
var winterNamePtr = allocate(intArrayFromString(winterName), 'i8', ALLOC_NORMAL);
|
|
var summerNamePtr = allocate(intArrayFromString(summerName), 'i8', ALLOC_NORMAL);
|
|
if (summer.getTimezoneOffset() < winter.getTimezoneOffset()) {
|
|
// Northern hemisphere
|
|
HEAP32[((__get_tzname())>>2)]=winterNamePtr;
|
|
HEAP32[(((__get_tzname())+(4))>>2)]=summerNamePtr;
|
|
} else {
|
|
HEAP32[((__get_tzname())>>2)]=summerNamePtr;
|
|
HEAP32[(((__get_tzname())+(4))>>2)]=winterNamePtr;
|
|
}
|
|
}
|
|
|
|
Module["_tzset"] = _tzset;function _mktime(tmPtr) {
|
|
_tzset();
|
|
var date = new Date(HEAP32[(((tmPtr)+(20))>>2)] + 1900,
|
|
HEAP32[(((tmPtr)+(16))>>2)],
|
|
HEAP32[(((tmPtr)+(12))>>2)],
|
|
HEAP32[(((tmPtr)+(8))>>2)],
|
|
HEAP32[(((tmPtr)+(4))>>2)],
|
|
HEAP32[((tmPtr)>>2)],
|
|
0);
|
|
|
|
// There's an ambiguous hour when the time goes back; the tm_isdst field is
|
|
// used to disambiguate it. Date() basically guesses, so we fix it up if it
|
|
// guessed wrong, or fill in tm_isdst with the guess if it's -1.
|
|
var dst = HEAP32[(((tmPtr)+(32))>>2)];
|
|
var guessedOffset = date.getTimezoneOffset();
|
|
var start = new Date(date.getFullYear(), 0, 1);
|
|
var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
|
|
var winterOffset = start.getTimezoneOffset();
|
|
var dstOffset = Math.min(winterOffset, summerOffset); // DST is in December in South
|
|
if (dst < 0) {
|
|
// Attention: some regions don't have DST at all.
|
|
HEAP32[(((tmPtr)+(32))>>2)]=Number(summerOffset != winterOffset && dstOffset == guessedOffset);
|
|
} else if ((dst > 0) != (dstOffset == guessedOffset)) {
|
|
var nonDstOffset = Math.max(winterOffset, summerOffset);
|
|
var trueOffset = dst > 0 ? dstOffset : nonDstOffset;
|
|
// Don't try setMinutes(date.getMinutes() + ...) -- it's messed up.
|
|
date.setTime(date.getTime() + (trueOffset - guessedOffset)*60000);
|
|
}
|
|
|
|
HEAP32[(((tmPtr)+(24))>>2)]=date.getDay();
|
|
var yday = ((date.getTime() - start.getTime()) / (1000 * 60 * 60 * 24))|0;
|
|
HEAP32[(((tmPtr)+(28))>>2)]=yday;
|
|
|
|
return (date.getTime() / 1000)|0;
|
|
}
|
|
Module["_mktime"] = _mktime;
|
|
|
|
function _pthread_cleanup_pop(execute) {
|
|
var routine = PThread.exitHandlers.pop();
|
|
if (execute) routine();
|
|
}
|
|
Module["_pthread_cleanup_pop"] = _pthread_cleanup_pop;
|
|
|
|
function _pthread_cleanup_push(routine, arg) {
|
|
if (PThread.exitHandlers === null) {
|
|
PThread.exitHandlers = [];
|
|
if (!ENVIRONMENT_IS_PTHREAD) {
|
|
__ATEXIT__.push(function() { PThread.runExitHandlers(); });
|
|
}
|
|
}
|
|
PThread.exitHandlers.push(function() { dynCall_vi(routine, arg) });
|
|
}
|
|
Module["_pthread_cleanup_push"] = _pthread_cleanup_push;
|
|
|
|
|
|
function __spawn_thread(threadParams) {
|
|
if (ENVIRONMENT_IS_PTHREAD) throw 'Internal Error! _spawn_thread() can only ever be called from main application thread!';
|
|
|
|
var worker = PThread.getNewWorker();
|
|
|
|
if (worker.pthread !== undefined) throw 'Internal error!';
|
|
if (!threadParams.pthread_ptr) throw 'Internal error, no pthread ptr!';
|
|
PThread.runningWorkers.push(worker);
|
|
|
|
// Allocate memory for thread-local storage and initialize it to zero.
|
|
var tlsMemory = _malloc(128 * 4);
|
|
for (var i = 0; i < 128; ++i) {
|
|
HEAP32[(((tlsMemory)+(i*4))>>2)]=0;
|
|
}
|
|
|
|
var stackHigh = threadParams.stackBase + threadParams.stackSize;
|
|
|
|
var pthread = PThread.pthreads[threadParams.pthread_ptr] = { // Create a pthread info object to represent this thread.
|
|
worker: worker,
|
|
stackBase: threadParams.stackBase,
|
|
stackSize: threadParams.stackSize,
|
|
allocatedOwnStack: threadParams.allocatedOwnStack,
|
|
thread: threadParams.pthread_ptr,
|
|
threadInfoStruct: threadParams.pthread_ptr // Info area for this thread in Emscripten HEAP (shared)
|
|
};
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 0 ) >> 2, 0); // threadStatus <- 0, meaning not yet exited.
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 4 ) >> 2, 0); // threadExitCode <- 0.
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 20 ) >> 2, 0); // profilerBlock <- 0.
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 80 ) >> 2, threadParams.detached);
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 116 ) >> 2, tlsMemory); // Init thread-local-storage memory array.
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 60 ) >> 2, 0); // Mark initial status to unused.
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 52 ) >> 2, pthread.threadInfoStruct); // Main thread ID.
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 56 ) >> 2, PROCINFO.pid); // Process ID.
|
|
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 120) >> 2, threadParams.stackSize);
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 96) >> 2, threadParams.stackSize);
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 92) >> 2, stackHigh);
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 120 + 8) >> 2, stackHigh);
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 120 + 12) >> 2, threadParams.detached);
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 120 + 20) >> 2, threadParams.schedPolicy);
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 120 + 24) >> 2, threadParams.schedPrio);
|
|
|
|
var global_libc = _emscripten_get_global_libc();
|
|
var global_locale = global_libc + 40;
|
|
Atomics.store(HEAPU32, (pthread.threadInfoStruct + 188) >> 2, global_locale);
|
|
|
|
|
|
worker.pthread = pthread;
|
|
var msg = {
|
|
'cmd': 'run',
|
|
'start_routine': threadParams.startRoutine,
|
|
'arg': threadParams.arg,
|
|
'threadInfoStruct': threadParams.pthread_ptr,
|
|
'selfThreadId': threadParams.pthread_ptr, // TODO: Remove this since thread ID is now the same as the thread address.
|
|
'parentThreadId': threadParams.parent_pthread_ptr,
|
|
'stackBase': threadParams.stackBase,
|
|
'stackSize': threadParams.stackSize,
|
|
};
|
|
worker.runPthread = function() {
|
|
// Ask the worker to start executing its pthread entry point function.
|
|
msg.time = performance.now();
|
|
worker.postMessage(msg, threadParams.transferList);
|
|
};
|
|
if (worker.loaded) {
|
|
worker.runPthread();
|
|
delete worker.runPthread;
|
|
}
|
|
}
|
|
Module["__spawn_thread"] = __spawn_thread;
|
|
|
|
function _pthread_getschedparam(thread, policy, schedparam) {
|
|
if (!policy && !schedparam) return ERRNO_CODES.EINVAL;
|
|
|
|
if (!thread) {
|
|
err('pthread_getschedparam called with a null thread pointer!');
|
|
return ERRNO_CODES.ESRCH;
|
|
}
|
|
var self = HEAP32[(((thread)+(24))>>2)];
|
|
if (self !== thread) {
|
|
err('pthread_getschedparam attempted on thread ' + thread + ', which does not point to a valid thread, or does not exist anymore!');
|
|
return ERRNO_CODES.ESRCH;
|
|
}
|
|
|
|
var schedPolicy = Atomics.load(HEAPU32, (thread + 120 + 20 ) >> 2);
|
|
var schedPrio = Atomics.load(HEAPU32, (thread + 120 + 24 ) >> 2);
|
|
|
|
if (policy) HEAP32[((policy)>>2)]=schedPolicy;
|
|
if (schedparam) HEAP32[((schedparam)>>2)]=schedPrio;
|
|
return 0;
|
|
}
|
|
Module["_pthread_getschedparam"] = _pthread_getschedparam;
|
|
|
|
function _pthread_self() {
|
|
return __pthread_ptr|0;
|
|
}
|
|
Module["_pthread_self"] = _pthread_self;function _pthread_create(pthread_ptr, attr, start_routine, arg) {
|
|
if (typeof SharedArrayBuffer === 'undefined') {
|
|
err('Current environment does not support SharedArrayBuffer, pthreads are not available!');
|
|
return 6;
|
|
}
|
|
if (!pthread_ptr) {
|
|
err('pthread_create called with a null thread pointer!');
|
|
return 28;
|
|
}
|
|
|
|
var transferList = []; // List of JS objects that will transfer ownership to the Worker hosting the thread
|
|
var error = 0;
|
|
|
|
|
|
// Synchronously proxy the thread creation to main thread if possible. If we need to transfer ownership of objects, then
|
|
// proxy asynchronously via postMessage.
|
|
if (ENVIRONMENT_IS_PTHREAD && (transferList.length === 0 || error)) {
|
|
return _emscripten_sync_run_in_main_thread_4(687865856, pthread_ptr, attr, start_routine, arg);
|
|
}
|
|
|
|
// If on the main thread, and accessing Canvas/OffscreenCanvas failed, abort with the detected error.
|
|
if (error) return error;
|
|
|
|
var stackSize = 0;
|
|
var stackBase = 0;
|
|
var detached = 0; // Default thread attr is PTHREAD_CREATE_JOINABLE, i.e. start as not detached.
|
|
var schedPolicy = 0; /*SCHED_OTHER*/
|
|
var schedPrio = 0;
|
|
if (attr) {
|
|
stackSize = HEAP32[((attr)>>2)];
|
|
// Musl has a convention that the stack size that is stored to the pthread attribute structure is always musl's #define DEFAULT_STACK_SIZE
|
|
// smaller than the actual created stack size. That is, stored stack size of 0 would mean a stack of DEFAULT_STACK_SIZE in size. All musl
|
|
// functions hide this impl detail, and offset the size transparently, so pthread_*() API user does not see this offset when operating with
|
|
// the pthread API. When reading the structure directly on JS side however, we need to offset the size manually here.
|
|
stackSize += 81920 /*DEFAULT_STACK_SIZE*/;
|
|
stackBase = HEAP32[(((attr)+(8))>>2)];
|
|
detached = HEAP32[(((attr)+(12))>>2)] !== 0/*PTHREAD_CREATE_JOINABLE*/;
|
|
var inheritSched = HEAP32[(((attr)+(16))>>2)] === 0/*PTHREAD_INHERIT_SCHED*/;
|
|
if (inheritSched) {
|
|
var prevSchedPolicy = HEAP32[(((attr)+(20))>>2)];
|
|
var prevSchedPrio = HEAP32[(((attr)+(24))>>2)];
|
|
// If we are inheriting the scheduling properties from the parent thread, we need to identify the parent thread properly - this function call may
|
|
// be getting proxied, in which case _pthread_self() will point to the thread performing the proxying, not the thread that initiated the call.
|
|
var parentThreadPtr = PThread.currentProxiedOperationCallerThread ? PThread.currentProxiedOperationCallerThread : _pthread_self();
|
|
_pthread_getschedparam(parentThreadPtr, attr + 20, attr + 24);
|
|
schedPolicy = HEAP32[(((attr)+(20))>>2)];
|
|
schedPrio = HEAP32[(((attr)+(24))>>2)];
|
|
HEAP32[(((attr)+(20))>>2)]=prevSchedPolicy;
|
|
HEAP32[(((attr)+(24))>>2)]=prevSchedPrio;
|
|
} else {
|
|
schedPolicy = HEAP32[(((attr)+(20))>>2)];
|
|
schedPrio = HEAP32[(((attr)+(24))>>2)];
|
|
}
|
|
} else {
|
|
// According to http://man7.org/linux/man-pages/man3/pthread_create.3.html, default stack size if not specified is 2 MB, so follow that convention.
|
|
stackSize = 2097152;
|
|
}
|
|
var allocatedOwnStack = stackBase == 0; // If allocatedOwnStack == true, then the pthread impl maintains the stack allocation.
|
|
if (allocatedOwnStack) {
|
|
stackBase = _memalign(16, stackSize); // Allocate a stack if the user doesn't want to place the stack in a custom memory area.
|
|
} else {
|
|
// Musl stores the stack base address assuming stack grows downwards, so adjust it to Emscripten convention that the
|
|
// stack grows upwards instead.
|
|
stackBase -= stackSize;
|
|
assert(stackBase > 0);
|
|
}
|
|
|
|
// Allocate thread block (pthread_t structure).
|
|
var threadInfoStruct = _malloc(244);
|
|
for (var i = 0; i < 244 >> 2; ++i) HEAPU32[(threadInfoStruct>>2) + i] = 0; // zero-initialize thread structure.
|
|
HEAP32[((pthread_ptr)>>2)]=threadInfoStruct;
|
|
|
|
// The pthread struct has a field that points to itself - this is used as a magic ID to detect whether the pthread_t
|
|
// structure is 'alive'.
|
|
HEAP32[(((threadInfoStruct)+(24))>>2)]=threadInfoStruct;
|
|
|
|
// pthread struct robust_list head should point to itself.
|
|
var headPtr = threadInfoStruct + 168;
|
|
HEAP32[((headPtr)>>2)]=headPtr;
|
|
|
|
|
|
var threadParams = {
|
|
stackBase: stackBase,
|
|
stackSize: stackSize,
|
|
allocatedOwnStack: allocatedOwnStack,
|
|
schedPolicy: schedPolicy,
|
|
schedPrio: schedPrio,
|
|
detached: detached,
|
|
startRoutine: start_routine,
|
|
pthread_ptr: threadInfoStruct,
|
|
parent_pthread_ptr: _pthread_self(),
|
|
arg: arg,
|
|
transferList: transferList
|
|
};
|
|
|
|
if (ENVIRONMENT_IS_PTHREAD) {
|
|
// The prepopulated pool of web workers that can host pthreads is stored in the main JS thread. Therefore if a
|
|
// pthread is attempting to spawn a new thread, the thread creation must be deferred to the main JS thread.
|
|
threadParams.cmd = 'spawnThread';
|
|
postMessage(threadParams, transferList);
|
|
} else {
|
|
// We are the main thread, so we have the pthread warmup pool in this thread and can fire off JS thread creation
|
|
// directly ourselves.
|
|
__spawn_thread(threadParams);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
Module["_pthread_create"] = _pthread_create;
|
|
|
|
|
|
|
|
function _setTempRet0($i) {
|
|
setTempRet0(($i) | 0);
|
|
}
|
|
Module["_setTempRet0"] = _setTempRet0;
|
|
|
|
|
|
|
|
function __isLeapYear(year) {
|
|
return year%4 === 0 && (year%100 !== 0 || year%400 === 0);
|
|
}
|
|
Module["__isLeapYear"] = __isLeapYear;
|
|
|
|
function __arraySum(array, index) {
|
|
var sum = 0;
|
|
for (var i = 0; i <= index; sum += array[i++]);
|
|
return sum;
|
|
}
|
|
Module["__arraySum"] = __arraySum;
|
|
|
|
|
|
var __MONTH_DAYS_LEAP=[31,29,31,30,31,30,31,31,30,31,30,31];
|
|
Module["__MONTH_DAYS_LEAP"] = __MONTH_DAYS_LEAP;
|
|
|
|
var __MONTH_DAYS_REGULAR=[31,28,31,30,31,30,31,31,30,31,30,31];
|
|
Module["__MONTH_DAYS_REGULAR"] = __MONTH_DAYS_REGULAR;function __addDays(date, days) {
|
|
var newDate = new Date(date.getTime());
|
|
while(days > 0) {
|
|
var leap = __isLeapYear(newDate.getFullYear());
|
|
var currentMonth = newDate.getMonth();
|
|
var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth];
|
|
|
|
if (days > daysInCurrentMonth-newDate.getDate()) {
|
|
// we spill over to next month
|
|
days -= (daysInCurrentMonth-newDate.getDate()+1);
|
|
newDate.setDate(1);
|
|
if (currentMonth < 11) {
|
|
newDate.setMonth(currentMonth+1)
|
|
} else {
|
|
newDate.setMonth(0);
|
|
newDate.setFullYear(newDate.getFullYear()+1);
|
|
}
|
|
} else {
|
|
// we stay in current month
|
|
newDate.setDate(newDate.getDate()+days);
|
|
return newDate;
|
|
}
|
|
}
|
|
|
|
return newDate;
|
|
}
|
|
Module["__addDays"] = __addDays;function _strftime(s, maxsize, format, tm) {
|
|
// size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr);
|
|
// http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html
|
|
|
|
var tm_zone = HEAP32[(((tm)+(40))>>2)];
|
|
|
|
var date = {
|
|
tm_sec: HEAP32[((tm)>>2)],
|
|
tm_min: HEAP32[(((tm)+(4))>>2)],
|
|
tm_hour: HEAP32[(((tm)+(8))>>2)],
|
|
tm_mday: HEAP32[(((tm)+(12))>>2)],
|
|
tm_mon: HEAP32[(((tm)+(16))>>2)],
|
|
tm_year: HEAP32[(((tm)+(20))>>2)],
|
|
tm_wday: HEAP32[(((tm)+(24))>>2)],
|
|
tm_yday: HEAP32[(((tm)+(28))>>2)],
|
|
tm_isdst: HEAP32[(((tm)+(32))>>2)],
|
|
tm_gmtoff: HEAP32[(((tm)+(36))>>2)],
|
|
tm_zone: tm_zone ? UTF8ToString(tm_zone) : ''
|
|
};
|
|
|
|
var pattern = UTF8ToString(format);
|
|
|
|
// expand format
|
|
var EXPANSION_RULES_1 = {
|
|
'%c': '%a %b %d %H:%M:%S %Y', // Replaced by the locale's appropriate date and time representation - e.g., Mon Aug 3 14:02:01 2013
|
|
'%D': '%m/%d/%y', // Equivalent to %m / %d / %y
|
|
'%F': '%Y-%m-%d', // Equivalent to %Y - %m - %d
|
|
'%h': '%b', // Equivalent to %b
|
|
'%r': '%I:%M:%S %p', // Replaced by the time in a.m. and p.m. notation
|
|
'%R': '%H:%M', // Replaced by the time in 24-hour notation
|
|
'%T': '%H:%M:%S', // Replaced by the time
|
|
'%x': '%m/%d/%y', // Replaced by the locale's appropriate date representation
|
|
'%X': '%H:%M:%S', // Replaced by the locale's appropriate time representation
|
|
// Modified Conversion Specifiers
|
|
'%Ec': '%c', // Replaced by the locale's alternative appropriate date and time representation.
|
|
'%EC': '%C', // Replaced by the name of the base year (period) in the locale's alternative representation.
|
|
'%Ex': '%m/%d/%y', // Replaced by the locale's alternative date representation.
|
|
'%EX': '%H:%M:%S', // Replaced by the locale's alternative time representation.
|
|
'%Ey': '%y', // Replaced by the offset from %EC (year only) in the locale's alternative representation.
|
|
'%EY': '%Y', // Replaced by the full alternative year representation.
|
|
'%Od': '%d', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading zeros if there is any alternative symbol for zero; otherwise, with leading <space> characters.
|
|
'%Oe': '%e', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading <space> characters.
|
|
'%OH': '%H', // Replaced by the hour (24-hour clock) using the locale's alternative numeric symbols.
|
|
'%OI': '%I', // Replaced by the hour (12-hour clock) using the locale's alternative numeric symbols.
|
|
'%Om': '%m', // Replaced by the month using the locale's alternative numeric symbols.
|
|
'%OM': '%M', // Replaced by the minutes using the locale's alternative numeric symbols.
|
|
'%OS': '%S', // Replaced by the seconds using the locale's alternative numeric symbols.
|
|
'%Ou': '%u', // Replaced by the weekday as a number in the locale's alternative representation (Monday=1).
|
|
'%OU': '%U', // Replaced by the week number of the year (Sunday as the first day of the week, rules corresponding to %U ) using the locale's alternative numeric symbols.
|
|
'%OV': '%V', // Replaced by the week number of the year (Monday as the first day of the week, rules corresponding to %V ) using the locale's alternative numeric symbols.
|
|
'%Ow': '%w', // Replaced by the number of the weekday (Sunday=0) using the locale's alternative numeric symbols.
|
|
'%OW': '%W', // Replaced by the week number of the year (Monday as the first day of the week) using the locale's alternative numeric symbols.
|
|
'%Oy': '%y', // Replaced by the year (offset from %C ) using the locale's alternative numeric symbols.
|
|
};
|
|
for (var rule in EXPANSION_RULES_1) {
|
|
pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_1[rule]);
|
|
}
|
|
|
|
var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
|
|
var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
|
|
|
|
function leadingSomething(value, digits, character) {
|
|
var str = typeof value === 'number' ? value.toString() : (value || '');
|
|
while (str.length < digits) {
|
|
str = character[0]+str;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
function leadingNulls(value, digits) {
|
|
return leadingSomething(value, digits, '0');
|
|
}
|
|
|
|
function compareByDay(date1, date2) {
|
|
function sgn(value) {
|
|
return value < 0 ? -1 : (value > 0 ? 1 : 0);
|
|
}
|
|
|
|
var compare;
|
|
if ((compare = sgn(date1.getFullYear()-date2.getFullYear())) === 0) {
|
|
if ((compare = sgn(date1.getMonth()-date2.getMonth())) === 0) {
|
|
compare = sgn(date1.getDate()-date2.getDate());
|
|
}
|
|
}
|
|
return compare;
|
|
}
|
|
|
|
function getFirstWeekStartDate(janFourth) {
|
|
switch (janFourth.getDay()) {
|
|
case 0: // Sunday
|
|
return new Date(janFourth.getFullYear()-1, 11, 29);
|
|
case 1: // Monday
|
|
return janFourth;
|
|
case 2: // Tuesday
|
|
return new Date(janFourth.getFullYear(), 0, 3);
|
|
case 3: // Wednesday
|
|
return new Date(janFourth.getFullYear(), 0, 2);
|
|
case 4: // Thursday
|
|
return new Date(janFourth.getFullYear(), 0, 1);
|
|
case 5: // Friday
|
|
return new Date(janFourth.getFullYear()-1, 11, 31);
|
|
case 6: // Saturday
|
|
return new Date(janFourth.getFullYear()-1, 11, 30);
|
|
}
|
|
}
|
|
|
|
function getWeekBasedYear(date) {
|
|
var thisDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday);
|
|
|
|
var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
|
|
var janFourthNextYear = new Date(thisDate.getFullYear()+1, 0, 4);
|
|
|
|
var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
|
|
var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
|
|
|
|
if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
|
|
// this date is after the start of the first week of this year
|
|
if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
|
|
return thisDate.getFullYear()+1;
|
|
} else {
|
|
return thisDate.getFullYear();
|
|
}
|
|
} else {
|
|
return thisDate.getFullYear()-1;
|
|
}
|
|
}
|
|
|
|
var EXPANSION_RULES_2 = {
|
|
'%a': function(date) {
|
|
return WEEKDAYS[date.tm_wday].substring(0,3);
|
|
},
|
|
'%A': function(date) {
|
|
return WEEKDAYS[date.tm_wday];
|
|
},
|
|
'%b': function(date) {
|
|
return MONTHS[date.tm_mon].substring(0,3);
|
|
},
|
|
'%B': function(date) {
|
|
return MONTHS[date.tm_mon];
|
|
},
|
|
'%C': function(date) {
|
|
var year = date.tm_year+1900;
|
|
return leadingNulls((year/100)|0,2);
|
|
},
|
|
'%d': function(date) {
|
|
return leadingNulls(date.tm_mday, 2);
|
|
},
|
|
'%e': function(date) {
|
|
return leadingSomething(date.tm_mday, 2, ' ');
|
|
},
|
|
'%g': function(date) {
|
|
// %g, %G, and %V give values according to the ISO 8601:2000 standard week-based year.
|
|
// In this system, weeks begin on a Monday and week 1 of the year is the week that includes
|
|
// January 4th, which is also the week that includes the first Thursday of the year, and
|
|
// is also the first week that contains at least four days in the year.
|
|
// If the first Monday of January is the 2nd, 3rd, or 4th, the preceding days are part of
|
|
// the last week of the preceding year; thus, for Saturday 2nd January 1999,
|
|
// %G is replaced by 1998 and %V is replaced by 53. If December 29th, 30th,
|
|
// or 31st is a Monday, it and any following days are part of week 1 of the following year.
|
|
// Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and %V is replaced by 01.
|
|
|
|
return getWeekBasedYear(date).toString().substring(2);
|
|
},
|
|
'%G': function(date) {
|
|
return getWeekBasedYear(date);
|
|
},
|
|
'%H': function(date) {
|
|
return leadingNulls(date.tm_hour, 2);
|
|
},
|
|
'%I': function(date) {
|
|
var twelveHour = date.tm_hour;
|
|
if (twelveHour == 0) twelveHour = 12;
|
|
else if (twelveHour > 12) twelveHour -= 12;
|
|
return leadingNulls(twelveHour, 2);
|
|
},
|
|
'%j': function(date) {
|
|
// Day of the year (001-366)
|
|
return leadingNulls(date.tm_mday+__arraySum(__isLeapYear(date.tm_year+1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon-1), 3);
|
|
},
|
|
'%m': function(date) {
|
|
return leadingNulls(date.tm_mon+1, 2);
|
|
},
|
|
'%M': function(date) {
|
|
return leadingNulls(date.tm_min, 2);
|
|
},
|
|
'%n': function() {
|
|
return '\n';
|
|
},
|
|
'%p': function(date) {
|
|
if (date.tm_hour >= 0 && date.tm_hour < 12) {
|
|
return 'AM';
|
|
} else {
|
|
return 'PM';
|
|
}
|
|
},
|
|
'%S': function(date) {
|
|
return leadingNulls(date.tm_sec, 2);
|
|
},
|
|
'%t': function() {
|
|
return '\t';
|
|
},
|
|
'%u': function(date) {
|
|
return date.tm_wday || 7;
|
|
},
|
|
'%U': function(date) {
|
|
// Replaced by the week number of the year as a decimal number [00,53].
|
|
// The first Sunday of January is the first day of week 1;
|
|
// days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday]
|
|
var janFirst = new Date(date.tm_year+1900, 0, 1);
|
|
var firstSunday = janFirst.getDay() === 0 ? janFirst : __addDays(janFirst, 7-janFirst.getDay());
|
|
var endDate = new Date(date.tm_year+1900, date.tm_mon, date.tm_mday);
|
|
|
|
// is target date after the first Sunday?
|
|
if (compareByDay(firstSunday, endDate) < 0) {
|
|
// calculate difference in days between first Sunday and endDate
|
|
var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth()-1)-31;
|
|
var firstSundayUntilEndJanuary = 31-firstSunday.getDate();
|
|
var days = firstSundayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate();
|
|
return leadingNulls(Math.ceil(days/7), 2);
|
|
}
|
|
|
|
return compareByDay(firstSunday, janFirst) === 0 ? '01': '00';
|
|
},
|
|
'%V': function(date) {
|
|
// Replaced by the week number of the year (Monday as the first day of the week)
|
|
// as a decimal number [01,53]. If the week containing 1 January has four
|
|
// or more days in the new year, then it is considered week 1.
|
|
// Otherwise, it is the last week of the previous year, and the next week is week 1.
|
|
// Both January 4th and the first Thursday of January are always in week 1. [ tm_year, tm_wday, tm_yday]
|
|
var janFourthThisYear = new Date(date.tm_year+1900, 0, 4);
|
|
var janFourthNextYear = new Date(date.tm_year+1901, 0, 4);
|
|
|
|
var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
|
|
var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
|
|
|
|
var endDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday);
|
|
|
|
if (compareByDay(endDate, firstWeekStartThisYear) < 0) {
|
|
// if given date is before this years first week, then it belongs to the 53rd week of last year
|
|
return '53';
|
|
}
|
|
|
|
if (compareByDay(firstWeekStartNextYear, endDate) <= 0) {
|
|
// if given date is after next years first week, then it belongs to the 01th week of next year
|
|
return '01';
|
|
}
|
|
|
|
// given date is in between CW 01..53 of this calendar year
|
|
var daysDifference;
|
|
if (firstWeekStartThisYear.getFullYear() < date.tm_year+1900) {
|
|
// first CW of this year starts last year
|
|
daysDifference = date.tm_yday+32-firstWeekStartThisYear.getDate()
|
|
} else {
|
|
// first CW of this year starts this year
|
|
daysDifference = date.tm_yday+1-firstWeekStartThisYear.getDate();
|
|
}
|
|
return leadingNulls(Math.ceil(daysDifference/7), 2);
|
|
},
|
|
'%w': function(date) {
|
|
return date.tm_wday;
|
|
},
|
|
'%W': function(date) {
|
|
// Replaced by the week number of the year as a decimal number [00,53].
|
|
// The first Monday of January is the first day of week 1;
|
|
// days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday]
|
|
var janFirst = new Date(date.tm_year, 0, 1);
|
|
var firstMonday = janFirst.getDay() === 1 ? janFirst : __addDays(janFirst, janFirst.getDay() === 0 ? 1 : 7-janFirst.getDay()+1);
|
|
var endDate = new Date(date.tm_year+1900, date.tm_mon, date.tm_mday);
|
|
|
|
// is target date after the first Monday?
|
|
if (compareByDay(firstMonday, endDate) < 0) {
|
|
var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth()-1)-31;
|
|
var firstMondayUntilEndJanuary = 31-firstMonday.getDate();
|
|
var days = firstMondayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate();
|
|
return leadingNulls(Math.ceil(days/7), 2);
|
|
}
|
|
return compareByDay(firstMonday, janFirst) === 0 ? '01': '00';
|
|
},
|
|
'%y': function(date) {
|
|
// Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year]
|
|
return (date.tm_year+1900).toString().substring(2);
|
|
},
|
|
'%Y': function(date) {
|
|
// Replaced by the year as a decimal number (for example, 1997). [ tm_year]
|
|
return date.tm_year+1900;
|
|
},
|
|
'%z': function(date) {
|
|
// Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ).
|
|
// For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich).
|
|
var off = date.tm_gmtoff;
|
|
var ahead = off >= 0;
|
|
off = Math.abs(off) / 60;
|
|
// convert from minutes into hhmm format (which means 60 minutes = 100 units)
|
|
off = (off / 60)*100 + (off % 60);
|
|
return (ahead ? '+' : '-') + String("0000" + off).slice(-4);
|
|
},
|
|
'%Z': function(date) {
|
|
return date.tm_zone;
|
|
},
|
|
'%%': function() {
|
|
return '%';
|
|
}
|
|
};
|
|
for (var rule in EXPANSION_RULES_2) {
|
|
if (pattern.indexOf(rule) >= 0) {
|
|
pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_2[rule](date));
|
|
}
|
|
}
|
|
|
|
var bytes = intArrayFromString(pattern, false);
|
|
if (bytes.length > maxsize) {
|
|
return 0;
|
|
}
|
|
|
|
writeArrayToMemory(bytes, s);
|
|
return bytes.length-1;
|
|
}
|
|
Module["_strftime"] = _strftime;function _strftime_l(s, maxsize, format, tm) {
|
|
return _strftime(s, maxsize, format, tm); // no locale support yet
|
|
}
|
|
Module["_strftime_l"] = _strftime_l;
|
|
|
|
function _sysconf(name) {
|
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(23, 1, name);
|
|
|
|
// long sysconf(int name);
|
|
// http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html
|
|
switch(name) {
|
|
case 30: return PAGE_SIZE;
|
|
case 85:
|
|
var maxHeapSize = 2*1024*1024*1024 - 65536;
|
|
maxHeapSize = HEAPU8.length;
|
|
return maxHeapSize / PAGE_SIZE;
|
|
case 132:
|
|
case 133:
|
|
case 12:
|
|
case 137:
|
|
case 138:
|
|
case 15:
|
|
case 235:
|
|
case 16:
|
|
case 17:
|
|
case 18:
|
|
case 19:
|
|
case 20:
|
|
case 149:
|
|
case 13:
|
|
case 10:
|
|
case 236:
|
|
case 153:
|
|
case 9:
|
|
case 21:
|
|
case 22:
|
|
case 159:
|
|
case 154:
|
|
case 14:
|
|
case 77:
|
|
case 78:
|
|
case 139:
|
|
case 80:
|
|
case 81:
|
|
case 82:
|
|
case 68:
|
|
case 67:
|
|
case 164:
|
|
case 11:
|
|
case 29:
|
|
case 47:
|
|
case 48:
|
|
case 95:
|
|
case 52:
|
|
case 51:
|
|
case 46:
|
|
return 200809;
|
|
case 79:
|
|
return 0;
|
|
case 27:
|
|
case 246:
|
|
case 127:
|
|
case 128:
|
|
case 23:
|
|
case 24:
|
|
case 160:
|
|
case 161:
|
|
case 181:
|
|
case 182:
|
|
case 242:
|
|
case 183:
|
|
case 184:
|
|
case 243:
|
|
case 244:
|
|
case 245:
|
|
case 165:
|
|
case 178:
|
|
case 179:
|
|
case 49:
|
|
case 50:
|
|
case 168:
|
|
case 169:
|
|
case 175:
|
|
case 170:
|
|
case 171:
|
|
case 172:
|
|
case 97:
|
|
case 76:
|
|
case 32:
|
|
case 173:
|
|
case 35:
|
|
return -1;
|
|
case 176:
|
|
case 177:
|
|
case 7:
|
|
case 155:
|
|
case 8:
|
|
case 157:
|
|
case 125:
|
|
case 126:
|
|
case 92:
|
|
case 93:
|
|
case 129:
|
|
case 130:
|
|
case 131:
|
|
case 94:
|
|
case 91:
|
|
return 1;
|
|
case 74:
|
|
case 60:
|
|
case 69:
|
|
case 70:
|
|
case 4:
|
|
return 1024;
|
|
case 31:
|
|
case 42:
|
|
case 72:
|
|
return 32;
|
|
case 87:
|
|
case 26:
|
|
case 33:
|
|
return 2147483647;
|
|
case 34:
|
|
case 1:
|
|
return 47839;
|
|
case 38:
|
|
case 36:
|
|
return 99;
|
|
case 43:
|
|
case 37:
|
|
return 2048;
|
|
case 0: return 2097152;
|
|
case 3: return 65536;
|
|
case 28: return 32768;
|
|
case 44: return 32767;
|
|
case 75: return 16384;
|
|
case 39: return 1000;
|
|
case 89: return 700;
|
|
case 71: return 256;
|
|
case 40: return 255;
|
|
case 2: return 100;
|
|
case 180: return 64;
|
|
case 25: return 20;
|
|
case 5: return 16;
|
|
case 6: return 6;
|
|
case 73: return 4;
|
|
case 84: {
|
|
if (typeof navigator === 'object') return navigator['hardwareConcurrency'] || 1;
|
|
return 1;
|
|
}
|
|
}
|
|
___setErrNo(28);
|
|
return -1;
|
|
}
|
|
|
|
Module["_sysconf"] = _sysconf;
|
|
|
|
function _system(command) {
|
|
// int system(const char *command);
|
|
// http://pubs.opengroup.org/onlinepubs/000095399/functions/system.html
|
|
// Can't call external programs.
|
|
___setErrNo(6);
|
|
return -1;
|
|
}
|
|
Module["_system"] = _system;
|
|
|
|
|
|
function _time(ptr) {
|
|
var ret = (Date.now()/1000)|0;
|
|
if (ptr) {
|
|
HEAP32[((ptr)>>2)]=ret;
|
|
}
|
|
return ret;
|
|
}
|
|
Module["_time"] = _time;
|
|
|
|
function _times(buffer) {
|
|
// clock_t times(struct tms *buffer);
|
|
// http://pubs.opengroup.org/onlinepubs/009695399/functions/times.html
|
|
// NOTE: This is fake, since we can't calculate real CPU time usage in JS.
|
|
if (buffer !== 0) {
|
|
_memset(buffer, 0, 16);
|
|
}
|
|
return 0;
|
|
}
|
|
Module["_times"] = _times;
|
|
if (!ENVIRONMENT_IS_PTHREAD) PThread.initMainThreadBlock(); else PThread.initWorker();;
|
|
if (ENVIRONMENT_IS_NODE) {
|
|
_emscripten_get_now = function _emscripten_get_now_actual() {
|
|
var t = process['hrtime']();
|
|
return t[0] * 1e3 + t[1] / 1e6;
|
|
};
|
|
} else if (ENVIRONMENT_IS_PTHREAD) {
|
|
_emscripten_get_now = function() { return performance['now']() - __performance_now_clock_drift; };
|
|
} else if (typeof dateNow !== 'undefined') {
|
|
_emscripten_get_now = dateNow;
|
|
} else if (typeof performance === 'object' && performance && typeof performance['now'] === 'function') {
|
|
_emscripten_get_now = function() { return performance['now'](); };
|
|
} else {
|
|
_emscripten_get_now = Date.now;
|
|
};
|
|
FS.staticInit();;
|
|
if (ENVIRONMENT_HAS_NODE) { var fs = require("fs"); var NODEJS_PATH = require("path"); NODEFS.staticInit(); };
|
|
var GLctx; GL.init();
|
|
|
|
// proxiedFunctionTable specifies the list of functions that can be called either synchronously or asynchronously from other threads in postMessage()d or internally queued events. This way a pthread in a Worker can synchronously access e.g. the DOM on the main thread.
|
|
|
|
var proxiedFunctionTable = [null,_atexit,___syscall10,___syscall12,___syscall183,___syscall195,___syscall196,___syscall220,___syscall221,___syscall3,___syscall39,___syscall4,___syscall40,___syscall5,___syscall54,___syscall85,___syscall91,_emscripten_set_canvas_element_size_main_thread,_fd_close,_fd_read,_fd_seek,_fd_write,_tzset,_sysconf];
|
|
|
|
var ASSERTIONS = false;
|
|
|
|
// Copyright 2017 The Emscripten Authors. All rights reserved.
|
|
// Emscripten is available under two separate licenses, the MIT license and the
|
|
// University of Illinois/NCSA Open Source License. Both these licenses can be
|
|
// found in the LICENSE file.
|
|
|
|
/** @type {function(string, boolean=, number=)} */
|
|
function intArrayFromString(stringy, dontAddNull, length) {
|
|
var len = length > 0 ? length : lengthBytesUTF8(stringy)+1;
|
|
var u8array = new Array(len);
|
|
var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
|
|
if (dontAddNull) u8array.length = numBytesWritten;
|
|
return u8array;
|
|
}
|
|
|
|
function intArrayToString(array) {
|
|
var ret = [];
|
|
for (var i = 0; i < array.length; i++) {
|
|
var chr = array[i];
|
|
if (chr > 0xFF) {
|
|
if (ASSERTIONS) {
|
|
assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.');
|
|
}
|
|
chr &= 0xFF;
|
|
}
|
|
ret.push(String.fromCharCode(chr));
|
|
}
|
|
return ret.join('');
|
|
}
|
|
|
|
|
|
// ASM_LIBRARY EXTERN PRIMITIVES: Int8Array,Int32Array
|
|
|
|
var asmGlobalArg = {};
|
|
var asmLibraryArg = { "_ZN12CPdfRenderer10SaveToFileERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE": __ZN12CPdfRenderer10SaveToFileERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE, "_ZN12CPdfRenderer11SetPasswordERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE": __ZN12CPdfRenderer11SetPasswordERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE, "_ZN12CPdfRenderer13SetDocumentIDERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE": __ZN12CPdfRenderer13SetDocumentIDERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE, "_ZN12CPdfRenderer13SetTempFolderERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE": __ZN12CPdfRenderer13SetTempFolderERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE, "_ZN12CPdfRenderer14SetThemesPlaceERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE": __ZN12CPdfRenderer14SetThemesPlaceERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEE, "_ZN12CPdfRenderer15OnlineWordToPdfERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_": __ZN12CPdfRenderer15OnlineWordToPdfERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_, "_ZN12CPdfRenderer25OnlineWordToPdfFromBinaryERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_": __ZN12CPdfRenderer25OnlineWordToPdfFromBinaryERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_, "_ZN12CPdfRendererC1EPN7NSFonts17IApplicationFontsEb": __ZN12CPdfRendererC1EPN7NSFonts17IApplicationFontsEb, "_ZN12CPdfRendererD1Ev": __ZN12CPdfRendererD1Ev, "_ZN14NSDoctRenderer13CDoctrenderer18GetImagesInChangesEv": __ZN14NSDoctRenderer13CDoctrenderer18GetImagesInChangesEv, "_ZN14NSDoctRenderer13CDoctrenderer7ExecuteERKNSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEERS7_": __ZN14NSDoctRenderer13CDoctrenderer7ExecuteERKNSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEERS7_, "_ZN14NSDoctRenderer13CDoctrendererC1ERKNSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEE": __ZN14NSDoctRenderer13CDoctrendererC1ERKNSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEE, "_ZN14NSDoctRenderer13CDoctrendererD1Ev": __ZN14NSDoctRenderer13CDoctrendererD1Ev, "_ZN14NSHtmlRenderer17CASCHTMLRenderer316CreateOfficeFileENSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEERKS7_": __ZN14NSHtmlRenderer17CASCHTMLRenderer316CreateOfficeFileENSt3__212basic_stringIwNS1_11char_traitsIwEENS1_9allocatorIwEEEERKS7_, "_ZN14NSHtmlRenderer17CASCHTMLRenderer39CloseFileEb": __ZN14NSHtmlRenderer17CASCHTMLRenderer39CloseFileEb, "_ZN14NSHtmlRenderer17CASCHTMLRenderer3C1Ev": __ZN14NSHtmlRenderer17CASCHTMLRenderer3C1Ev, "_ZN14NSHtmlRenderer17CASCHTMLRenderer3D1Ev": __ZN14NSHtmlRenderer17CASCHTMLRenderer3D1Ev, "_ZN18NSUnicodeConverter17CUnicodeConverter11fromUnicodeEPKwRKjPKc": __ZN18NSUnicodeConverter17CUnicodeConverter11fromUnicodeEPKwRKjPKc, "_ZN18NSUnicodeConverter17CUnicodeConverter14toUnicodeExactEPKcRKjS2_": __ZN18NSUnicodeConverter17CUnicodeConverter14toUnicodeExactEPKcRKjS2_, "_ZN18NSUnicodeConverter17CUnicodeConverter14toUnicodeExactEPKcRKji": __ZN18NSUnicodeConverter17CUnicodeConverter14toUnicodeExactEPKcRKji, "_ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeEPKcRKjS2_": __ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeEPKcRKjS2_, "_ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeERKNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKc": __ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeERKNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKc, "_ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeERKNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEi": __ZN18NSUnicodeConverter17CUnicodeConverter9toUnicodeERKNSt3__212basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEi, "_ZN18NSUnicodeConverter17CUnicodeConverterC1Ev": __ZN18NSUnicodeConverter17CUnicodeConverterC1Ev, "_ZN18NSUnicodeConverter17CUnicodeConverterD1Ev": __ZN18NSUnicodeConverter17CUnicodeConverterD1Ev, "_ZN23CFileDownloader_privateC1ENSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEEb": __ZN23CFileDownloader_privateC1ENSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEEb, "_ZN8CXpsFileC1EPN7NSFonts17IApplicationFontsE": __ZN8CXpsFileC1EPN7NSFonts17IApplicationFontsE, "_ZN9CDjVuFileC1EPN7NSFonts17IApplicationFontsE": __ZN9CDjVuFileC1EPN7NSFonts17IApplicationFontsE, "_ZN9CHtmlFile10ConvertMhtERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_S8_": __ZN9CHtmlFile10ConvertMhtERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEES8_S8_, "_ZN9CHtmlFile11ConvertEpubERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEERS6_S8_S8_": __ZN9CHtmlFile11ConvertEpubERKNSt3__212basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEERS6_S8_S8_, "_ZN9CHtmlFile7ConvertERKNSt3__26vectorINS0_12basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEENS5_IS7_EEEERKS7_SD_": __ZN9CHtmlFile7ConvertERKNSt3__26vectorINS0_12basic_stringIwNS0_11char_traitsIwEENS0_9allocatorIwEEEENS5_IS7_EEEERKS7_SD_, "_ZN9CHtmlFileC1Ev": __ZN9CHtmlFileC1Ev, "_ZN9CHtmlFileD1Ev": __ZN9CHtmlFileD1Ev, "_ZN9PdfReader10CPdfReader8GetErrorEv": __ZN9PdfReader10CPdfReader8GetErrorEv, "_ZN9PdfReader10CPdfReaderC1EPN7NSFonts17IApplicationFontsE": __ZN9PdfReader10CPdfReaderC1EPN7NSFonts17IApplicationFontsE, "__assert_fail": ___assert_fail, "__call_main": ___call_main, "__clock_gettime": ___clock_gettime, "__cxa_allocate_exception": ___cxa_allocate_exception, "__cxa_atexit": ___cxa_atexit, "__cxa_rethrow": ___cxa_rethrow, "__cxa_throw": ___cxa_throw, "__lock": ___lock, "__map_file": ___map_file, "__syscall10": ___syscall10, "__syscall12": ___syscall12, "__syscall183": ___syscall183, "__syscall195": ___syscall195, "__syscall196": ___syscall196, "__syscall220": ___syscall220, "__syscall221": ___syscall221, "__syscall3": ___syscall3, "__syscall39": ___syscall39, "__syscall4": ___syscall4, "__syscall40": ___syscall40, "__syscall5": ___syscall5, "__syscall54": ___syscall54, "__syscall85": ___syscall85, "__syscall91": ___syscall91, "__unlock": ___unlock, "abort": _abort, "atexit": _atexit, "emscripten_asm_const_iii": _emscripten_asm_const_iii, "emscripten_check_blocking_allowed": _emscripten_check_blocking_allowed, "emscripten_conditional_set_current_thread_status": _emscripten_conditional_set_current_thread_status, "emscripten_futex_wait": _emscripten_futex_wait, "emscripten_futex_wake": _emscripten_futex_wake, "emscripten_get_now": _emscripten_get_now, "emscripten_get_sbrk_ptr": _emscripten_get_sbrk_ptr, "emscripten_has_threading_support": _emscripten_has_threading_support, "emscripten_is_main_browser_thread": _emscripten_is_main_browser_thread, "emscripten_is_main_runtime_thread": _emscripten_is_main_runtime_thread, "emscripten_longjmp": _emscripten_longjmp, "emscripten_memcpy_big": _emscripten_memcpy_big, "emscripten_receive_on_main_thread_js": _emscripten_receive_on_main_thread_js, "emscripten_resize_heap": _emscripten_resize_heap, "emscripten_set_canvas_element_size": _emscripten_set_canvas_element_size, "emscripten_set_current_thread_status": _emscripten_set_current_thread_status, "emscripten_set_thread_name": _emscripten_set_thread_name, "emscripten_syscall": _emscripten_syscall, "emscripten_webgl_create_context": _emscripten_webgl_create_context, "environ_get": _environ_get, "environ_sizes_get": _environ_sizes_get, "exit": _exit, "fd_close": _fd_close, "fd_read": _fd_read, "fd_seek": _fd_seek, "fd_write": _fd_write, "getTempRet0": _getTempRet0, "gettimeofday": _gettimeofday, "gmtime": _gmtime, "initPthreadsJS": initPthreadsJS, "invoke_ii": invoke_ii, "invoke_iii": invoke_iii, "invoke_iiii": invoke_iiii, "invoke_iiiii": invoke_iiiii, "invoke_iiiiii": invoke_iiiiii, "invoke_v": invoke_v, "invoke_vi": invoke_vi, "invoke_vii": invoke_vii, "invoke_viii": invoke_viii, "invoke_viiii": invoke_viiii, "invoke_viiiii": invoke_viiiii, "invoke_viiiiii": invoke_viiiiii, "invoke_viiiiiiiii": invoke_viiiiiiiii, "memory": wasmMemory, "mktime": _mktime, "pthread_cleanup_pop": _pthread_cleanup_pop, "pthread_cleanup_push": _pthread_cleanup_push, "pthread_create": _pthread_create, "pthread_self": _pthread_self, "saveSetjmp": _saveSetjmp, "setTempRet0": _setTempRet0, "strftime_l": _strftime_l, "sysconf": _sysconf, "system": _system, "table": wasmTable, "testSetjmp": _testSetjmp, "time": _time, "times": _times };
|
|
var asm = createWasm();
|
|
Module["asm"] = asm;
|
|
var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() {
|
|
return Module["asm"]["__wasm_call_ctors"].apply(null, arguments)
|
|
};
|
|
|
|
var _runX2T = Module["_runX2T"] = function() {
|
|
return Module["asm"]["runX2T"].apply(null, arguments)
|
|
};
|
|
|
|
var _malloc = Module["_malloc"] = function() {
|
|
return Module["asm"]["malloc"].apply(null, arguments)
|
|
};
|
|
|
|
var _free = Module["_free"] = function() {
|
|
return Module["asm"]["free"].apply(null, arguments)
|
|
};
|
|
|
|
var _main = Module["_main"] = function() {
|
|
return Module["asm"]["main"].apply(null, arguments)
|
|
};
|
|
|
|
var _realloc = Module["_realloc"] = function() {
|
|
return Module["asm"]["realloc"].apply(null, arguments)
|
|
};
|
|
|
|
var __ZSt18uncaught_exceptionv = Module["__ZSt18uncaught_exceptionv"] = function() {
|
|
return Module["asm"]["_ZSt18uncaught_exceptionv"].apply(null, arguments)
|
|
};
|
|
|
|
var ___errno_location = Module["___errno_location"] = function() {
|
|
return Module["asm"]["__errno_location"].apply(null, arguments)
|
|
};
|
|
|
|
var _ntohs = Module["_ntohs"] = function() {
|
|
return Module["asm"]["ntohs"].apply(null, arguments)
|
|
};
|
|
|
|
var _htonl = Module["_htonl"] = function() {
|
|
return Module["asm"]["htonl"].apply(null, arguments)
|
|
};
|
|
|
|
var _htons = Module["_htons"] = function() {
|
|
return Module["asm"]["htons"].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 ___em_js__initPthreadsJS = Module["___em_js__initPthreadsJS"] = function() {
|
|
return Module["asm"]["__em_js__initPthreadsJS"].apply(null, arguments)
|
|
};
|
|
|
|
var ___emscripten_pthread_data_constructor = Module["___emscripten_pthread_data_constructor"] = function() {
|
|
return Module["asm"]["__emscripten_pthread_data_constructor"].apply(null, arguments)
|
|
};
|
|
|
|
var __get_tzname = Module["__get_tzname"] = function() {
|
|
return Module["asm"]["_get_tzname"].apply(null, arguments)
|
|
};
|
|
|
|
var __get_daylight = Module["__get_daylight"] = function() {
|
|
return Module["asm"]["_get_daylight"].apply(null, arguments)
|
|
};
|
|
|
|
var __get_timezone = Module["__get_timezone"] = function() {
|
|
return Module["asm"]["_get_timezone"].apply(null, arguments)
|
|
};
|
|
|
|
var _setThrew = Module["_setThrew"] = function() {
|
|
return Module["asm"]["setThrew"].apply(null, arguments)
|
|
};
|
|
|
|
var _memalign = Module["_memalign"] = function() {
|
|
return Module["asm"]["memalign"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_main_browser_thread_id = Module["_emscripten_main_browser_thread_id"] = function() {
|
|
return Module["asm"]["emscripten_main_browser_thread_id"].apply(null, arguments)
|
|
};
|
|
|
|
var ___pthread_tsd_run_dtors = Module["___pthread_tsd_run_dtors"] = function() {
|
|
return Module["asm"]["__pthread_tsd_run_dtors"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_main_thread_process_queued_calls = Module["_emscripten_main_thread_process_queued_calls"] = function() {
|
|
return Module["asm"]["emscripten_main_thread_process_queued_calls"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_current_thread_process_queued_calls = Module["_emscripten_current_thread_process_queued_calls"] = function() {
|
|
return Module["asm"]["emscripten_current_thread_process_queued_calls"].apply(null, arguments)
|
|
};
|
|
|
|
var _usleep = Module["_usleep"] = function() {
|
|
return Module["asm"]["usleep"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_register_main_browser_thread_id = Module["_emscripten_register_main_browser_thread_id"] = function() {
|
|
return Module["asm"]["emscripten_register_main_browser_thread_id"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_async_run_in_main_thread = Module["_emscripten_async_run_in_main_thread"] = function() {
|
|
return Module["asm"]["emscripten_async_run_in_main_thread"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_sync_run_in_main_thread = Module["_emscripten_sync_run_in_main_thread"] = function() {
|
|
return Module["asm"]["emscripten_sync_run_in_main_thread"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_sync_run_in_main_thread_0 = Module["_emscripten_sync_run_in_main_thread_0"] = function() {
|
|
return Module["asm"]["emscripten_sync_run_in_main_thread_0"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_sync_run_in_main_thread_1 = Module["_emscripten_sync_run_in_main_thread_1"] = function() {
|
|
return Module["asm"]["emscripten_sync_run_in_main_thread_1"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_sync_run_in_main_thread_2 = Module["_emscripten_sync_run_in_main_thread_2"] = function() {
|
|
return Module["asm"]["emscripten_sync_run_in_main_thread_2"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_sync_run_in_main_thread_xprintf_varargs = Module["_emscripten_sync_run_in_main_thread_xprintf_varargs"] = function() {
|
|
return Module["asm"]["emscripten_sync_run_in_main_thread_xprintf_varargs"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_sync_run_in_main_thread_3 = Module["_emscripten_sync_run_in_main_thread_3"] = function() {
|
|
return Module["asm"]["emscripten_sync_run_in_main_thread_3"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_sync_run_in_main_thread_4 = Module["_emscripten_sync_run_in_main_thread_4"] = function() {
|
|
return Module["asm"]["emscripten_sync_run_in_main_thread_4"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_sync_run_in_main_thread_5 = Module["_emscripten_sync_run_in_main_thread_5"] = function() {
|
|
return Module["asm"]["emscripten_sync_run_in_main_thread_5"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_sync_run_in_main_thread_6 = Module["_emscripten_sync_run_in_main_thread_6"] = function() {
|
|
return Module["asm"]["emscripten_sync_run_in_main_thread_6"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_sync_run_in_main_thread_7 = Module["_emscripten_sync_run_in_main_thread_7"] = function() {
|
|
return Module["asm"]["emscripten_sync_run_in_main_thread_7"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_run_in_main_runtime_thread_js = Module["_emscripten_run_in_main_runtime_thread_js"] = function() {
|
|
return Module["asm"]["emscripten_run_in_main_runtime_thread_js"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_async_queue_on_thread_ = Module["_emscripten_async_queue_on_thread_"] = function() {
|
|
return Module["asm"]["emscripten_async_queue_on_thread_"].apply(null, arguments)
|
|
};
|
|
|
|
var _proxy_main = Module["_proxy_main"] = function() {
|
|
return Module["asm"]["proxy_main"].apply(null, arguments)
|
|
};
|
|
|
|
var _emscripten_tls_init = Module["_emscripten_tls_init"] = function() {
|
|
return Module["asm"]["emscripten_tls_init"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_ii = Module["dynCall_ii"] = function() {
|
|
return Module["asm"]["dynCall_ii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iii = Module["dynCall_iii"] = function() {
|
|
return Module["asm"]["dynCall_iii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiii = Module["dynCall_iiii"] = function() {
|
|
return Module["asm"]["dynCall_iiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiiii = Module["dynCall_iiiii"] = function() {
|
|
return Module["asm"]["dynCall_iiiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiiiii = Module["dynCall_iiiiii"] = function() {
|
|
return Module["asm"]["dynCall_iiiiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_v = Module["dynCall_v"] = function() {
|
|
return Module["asm"]["dynCall_v"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_vi = Module["dynCall_vi"] = function() {
|
|
return Module["asm"]["dynCall_vi"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_vii = Module["dynCall_vii"] = function() {
|
|
return Module["asm"]["dynCall_vii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viii = Module["dynCall_viii"] = function() {
|
|
return Module["asm"]["dynCall_viii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viiii = Module["dynCall_viiii"] = function() {
|
|
return Module["asm"]["dynCall_viiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viiiii = Module["dynCall_viiiii"] = function() {
|
|
return Module["asm"]["dynCall_viiiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viiiiii = Module["dynCall_viiiiii"] = function() {
|
|
return Module["asm"]["dynCall_viiiiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viiiiiiiii = Module["dynCall_viiiiiiiii"] = function() {
|
|
return Module["asm"]["dynCall_viiiiiiiii"].apply(null, arguments)
|
|
};
|
|
|
|
var stackSave = Module["stackSave"] = function() {
|
|
return Module["asm"]["stackSave"].apply(null, arguments)
|
|
};
|
|
|
|
var stackAlloc = Module["stackAlloc"] = function() {
|
|
return Module["asm"]["stackAlloc"].apply(null, arguments)
|
|
};
|
|
|
|
var stackRestore = Module["stackRestore"] = function() {
|
|
return Module["asm"]["stackRestore"].apply(null, arguments)
|
|
};
|
|
|
|
var __growWasmMemory = Module["__growWasmMemory"] = function() {
|
|
return Module["asm"]["__growWasmMemory"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viijii = Module["dynCall_viijii"] = function() {
|
|
return Module["asm"]["dynCall_viijii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_dii = Module["dynCall_dii"] = function() {
|
|
return Module["asm"]["dynCall_dii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_did = Module["dynCall_did"] = function() {
|
|
return Module["asm"]["dynCall_did"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_di = Module["dynCall_di"] = function() {
|
|
return Module["asm"]["dynCall_di"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_ji = Module["dynCall_ji"] = function() {
|
|
return Module["asm"]["dynCall_ji"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_vij = Module["dynCall_vij"] = function() {
|
|
return Module["asm"]["dynCall_vij"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_jii = Module["dynCall_jii"] = function() {
|
|
return Module["asm"]["dynCall_jii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = function() {
|
|
return Module["asm"]["dynCall_iiiiiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = function() {
|
|
return Module["asm"]["dynCall_iiiiiiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = function() {
|
|
return Module["asm"]["dynCall_iiiiiiiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iidddddi = Module["dynCall_iidddddi"] = function() {
|
|
return Module["asm"]["dynCall_iidddddi"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viiiddii = Module["dynCall_viiiddii"] = function() {
|
|
return Module["asm"]["dynCall_viiiddii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viij = Module["dynCall_viij"] = function() {
|
|
return Module["asm"]["dynCall_viij"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viji = Module["dynCall_viji"] = function() {
|
|
return Module["asm"]["dynCall_viji"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_jij = Module["dynCall_jij"] = function() {
|
|
return Module["asm"]["dynCall_jij"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiiijii = Module["dynCall_iiiijii"] = function() {
|
|
return Module["asm"]["dynCall_iiiijii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viiij = Module["dynCall_viiij"] = function() {
|
|
return Module["asm"]["dynCall_viiij"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viiiiiiiiii = Module["dynCall_viiiiiiiiii"] = function() {
|
|
return Module["asm"]["dynCall_viiiiiiiiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_i = Module["dynCall_i"] = function() {
|
|
return Module["asm"]["dynCall_i"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = function() {
|
|
return Module["asm"]["dynCall_viiiiiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viiiiiiiiiiii = Module["dynCall_viiiiiiiiiiii"] = function() {
|
|
return Module["asm"]["dynCall_viiiiiiiiiiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iidd = Module["dynCall_iidd"] = function() {
|
|
return Module["asm"]["dynCall_iidd"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iidddddd = Module["dynCall_iidddddd"] = function() {
|
|
return Module["asm"]["dynCall_iidddddd"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_vidd = Module["dynCall_vidd"] = function() {
|
|
return Module["asm"]["dynCall_vidd"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_vidddd = Module["dynCall_vidddd"] = function() {
|
|
return Module["asm"]["dynCall_vidddd"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viidddd = Module["dynCall_viidddd"] = function() {
|
|
return Module["asm"]["dynCall_viidddd"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viidddddd = Module["dynCall_viidddddd"] = function() {
|
|
return Module["asm"]["dynCall_viidddddd"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiiiiddd = Module["dynCall_iiiiiddd"] = function() {
|
|
return Module["asm"]["dynCall_iiiiiddd"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viiiiddd = Module["dynCall_viiiiddd"] = function() {
|
|
return Module["asm"]["dynCall_viiiiddd"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_diiii = Module["dynCall_diiii"] = function() {
|
|
return Module["asm"]["dynCall_diiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiidddd = Module["dynCall_iiidddd"] = function() {
|
|
return Module["asm"]["dynCall_iiidddd"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viddddiii = Module["dynCall_viddddiii"] = function() {
|
|
return Module["asm"]["dynCall_viddddiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_viiiddi = Module["dynCall_viiiddi"] = function() {
|
|
return Module["asm"]["dynCall_viiiddi"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_vidddddd = Module["dynCall_vidddddd"] = function() {
|
|
return Module["asm"]["dynCall_vidddddd"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = function() {
|
|
return Module["asm"]["dynCall_iiiiiiiiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_jiji = Module["dynCall_jiji"] = function() {
|
|
return Module["asm"]["dynCall_jiji"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iidiiii = Module["dynCall_iidiiii"] = function() {
|
|
return Module["asm"]["dynCall_iidiiii"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiiiij = Module["dynCall_iiiiij"] = function() {
|
|
return Module["asm"]["dynCall_iiiiij"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiiiid = Module["dynCall_iiiiid"] = function() {
|
|
return Module["asm"]["dynCall_iiiiid"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = function() {
|
|
return Module["asm"]["dynCall_iiiiijj"].apply(null, arguments)
|
|
};
|
|
|
|
var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = function() {
|
|
return Module["asm"]["dynCall_iiiiiijj"].apply(null, arguments)
|
|
};
|
|
|
|
|
|
function invoke_viiii(index,a1,a2,a3,a4) {
|
|
var sp = stackSave();
|
|
try {
|
|
dynCall_viiii(index,a1,a2,a3,a4);
|
|
} catch(e) {
|
|
stackRestore(sp);
|
|
if (e !== e+0 && e !== 'longjmp') throw e;
|
|
_setThrew(1, 0);
|
|
}
|
|
}
|
|
|
|
function invoke_iii(index,a1,a2) {
|
|
var sp = stackSave();
|
|
try {
|
|
return dynCall_iii(index,a1,a2);
|
|
} catch(e) {
|
|
stackRestore(sp);
|
|
if (e !== e+0 && e !== 'longjmp') throw e;
|
|
_setThrew(1, 0);
|
|
}
|
|
}
|
|
|
|
function invoke_iiiii(index,a1,a2,a3,a4) {
|
|
var sp = stackSave();
|
|
try {
|
|
return dynCall_iiiii(index,a1,a2,a3,a4);
|
|
} catch(e) {
|
|
stackRestore(sp);
|
|
if (e !== e+0 && e !== 'longjmp') throw e;
|
|
_setThrew(1, 0);
|
|
}
|
|
}
|
|
|
|
function invoke_iiii(index,a1,a2,a3) {
|
|
var sp = stackSave();
|
|
try {
|
|
return dynCall_iiii(index,a1,a2,a3);
|
|
} catch(e) {
|
|
stackRestore(sp);
|
|
if (e !== e+0 && e !== 'longjmp') throw e;
|
|
_setThrew(1, 0);
|
|
}
|
|
}
|
|
|
|
function invoke_vi(index,a1) {
|
|
var sp = stackSave();
|
|
try {
|
|
dynCall_vi(index,a1);
|
|
} catch(e) {
|
|
stackRestore(sp);
|
|
if (e !== e+0 && e !== 'longjmp') throw e;
|
|
_setThrew(1, 0);
|
|
}
|
|
}
|
|
|
|
function invoke_vii(index,a1,a2) {
|
|
var sp = stackSave();
|
|
try {
|
|
dynCall_vii(index,a1,a2);
|
|
} catch(e) {
|
|
stackRestore(sp);
|
|
if (e !== e+0 && e !== 'longjmp') throw e;
|
|
_setThrew(1, 0);
|
|
}
|
|
}
|
|
|
|
function invoke_ii(index,a1) {
|
|
var sp = stackSave();
|
|
try {
|
|
return dynCall_ii(index,a1);
|
|
} catch(e) {
|
|
stackRestore(sp);
|
|
if (e !== e+0 && e !== 'longjmp') throw e;
|
|
_setThrew(1, 0);
|
|
}
|
|
}
|
|
|
|
function invoke_viii(index,a1,a2,a3) {
|
|
var sp = stackSave();
|
|
try {
|
|
dynCall_viii(index,a1,a2,a3);
|
|
} catch(e) {
|
|
stackRestore(sp);
|
|
if (e !== e+0 && e !== 'longjmp') throw e;
|
|
_setThrew(1, 0);
|
|
}
|
|
}
|
|
|
|
function invoke_v(index) {
|
|
var sp = stackSave();
|
|
try {
|
|
dynCall_v(index);
|
|
} catch(e) {
|
|
stackRestore(sp);
|
|
if (e !== e+0 && e !== 'longjmp') throw e;
|
|
_setThrew(1, 0);
|
|
}
|
|
}
|
|
|
|
function invoke_iiiiii(index,a1,a2,a3,a4,a5) {
|
|
var sp = stackSave();
|
|
try {
|
|
return dynCall_iiiiii(index,a1,a2,a3,a4,a5);
|
|
} catch(e) {
|
|
stackRestore(sp);
|
|
if (e !== e+0 && e !== 'longjmp') throw e;
|
|
_setThrew(1, 0);
|
|
}
|
|
}
|
|
|
|
function invoke_viiiii(index,a1,a2,a3,a4,a5) {
|
|
var sp = stackSave();
|
|
try {
|
|
dynCall_viiiii(index,a1,a2,a3,a4,a5);
|
|
} catch(e) {
|
|
stackRestore(sp);
|
|
if (e !== e+0 && e !== 'longjmp') throw e;
|
|
_setThrew(1, 0);
|
|
}
|
|
}
|
|
|
|
function invoke_viiiiii(index,a1,a2,a3,a4,a5,a6) {
|
|
var sp = stackSave();
|
|
try {
|
|
dynCall_viiiiii(index,a1,a2,a3,a4,a5,a6);
|
|
} catch(e) {
|
|
stackRestore(sp);
|
|
if (e !== e+0 && e !== 'longjmp') throw e;
|
|
_setThrew(1, 0);
|
|
}
|
|
}
|
|
|
|
function invoke_viiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9) {
|
|
var sp = stackSave();
|
|
try {
|
|
dynCall_viiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9);
|
|
} catch(e) {
|
|
stackRestore(sp);
|
|
if (e !== e+0 && e !== 'longjmp') throw e;
|
|
_setThrew(1, 0);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// === Auto-generated postamble setup entry stuff ===
|
|
|
|
Module['asm'] = asm;
|
|
|
|
|
|
|
|
Module["ccall"] = ccall;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Module["establishStackSpace"] = establishStackSpace;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Module["PThread"] = PThread;
|
|
Module["ExitStatus"] = ExitStatus;
|
|
Module["tempDoublePtr"] = tempDoublePtr;
|
|
Module["wasmMemory"] = wasmMemory;
|
|
Module["_pthread_self"] = _pthread_self;
|
|
Module["ExitStatus"] = ExitStatus;
|
|
Module["tempDoublePtr"] = tempDoublePtr;
|
|
Module["dynCall_ii"] = dynCall_ii;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var calledRun;
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
* @this {ExitStatus}
|
|
*/
|
|
function ExitStatus(status) {
|
|
this.name = "ExitStatus";
|
|
this.message = "Program terminated with exit(" + status + ")";
|
|
this.status = status;
|
|
}
|
|
|
|
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 (!calledRun) run();
|
|
if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
|
|
};
|
|
|
|
function callMain(args) {
|
|
|
|
var entryFunction = Module['_main'];
|
|
|
|
|
|
args = args || [];
|
|
|
|
var argc = args.length+1;
|
|
var argv = stackAlloc((argc + 1) * 4);
|
|
HEAP32[argv >> 2] = allocateUTF8OnStack(thisProgram);
|
|
for (var i = 1; i < argc; i++) {
|
|
HEAP32[(argv >> 2) + i] = allocateUTF8OnStack(args[i - 1]);
|
|
}
|
|
HEAP32[(argv >> 2) + argc] = 0;
|
|
|
|
|
|
try {
|
|
|
|
|
|
var ret = entryFunction(argc, argv);
|
|
|
|
|
|
// 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
|
|
noExitRuntime = true;
|
|
return;
|
|
} else {
|
|
var toLog = e;
|
|
if (e && typeof e === 'object' && e.stack) {
|
|
toLog = [e, e.stack];
|
|
}
|
|
err('exception thrown: ' + toLog);
|
|
quit_(1, e);
|
|
}
|
|
} finally {
|
|
calledMain = true;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/** @type {function(Array=)} */
|
|
function run(args) {
|
|
args = args || arguments_;
|
|
|
|
if (runDependencies > 0) {
|
|
return;
|
|
}
|
|
|
|
|
|
preRun();
|
|
|
|
if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
|
|
|
|
function doRun() {
|
|
// run may have just been called through dependencies being fulfilled just in this very frame,
|
|
// or while the async setStatus time below was happening
|
|
if (calledRun) return;
|
|
calledRun = true;
|
|
|
|
if (ABORT) return;
|
|
|
|
initRuntime();
|
|
|
|
preMain();
|
|
|
|
if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();
|
|
|
|
if (shouldRunNow) callMain(args);
|
|
|
|
postRun();
|
|
}
|
|
|
|
if (Module['setStatus']) {
|
|
Module['setStatus']('Running...');
|
|
setTimeout(function() {
|
|
setTimeout(function() {
|
|
Module['setStatus']('');
|
|
}, 1);
|
|
doRun();
|
|
}, 1);
|
|
} else
|
|
{
|
|
doRun();
|
|
}
|
|
}
|
|
Module['run'] = run;
|
|
|
|
|
|
function exit(status, implicit) {
|
|
|
|
// if this is just main exit-ing implicitly, and the status is 0, then we
|
|
// don't need to do anything here and can just leave. if the status is
|
|
// non-zero, though, then we need to report it.
|
|
// (we may have warned about this earlier, if a situation justifies doing so)
|
|
if (implicit && noExitRuntime && status === 0) {
|
|
return;
|
|
}
|
|
|
|
if (noExitRuntime) {
|
|
} else {
|
|
PThread.terminateAllThreads();
|
|
|
|
ABORT = true;
|
|
EXITSTATUS = status;
|
|
|
|
exitRuntime();
|
|
|
|
if (Module['onExit']) Module['onExit'](status);
|
|
}
|
|
|
|
quit_(status, new ExitStatus(status));
|
|
}
|
|
|
|
if (Module['preInit']) {
|
|
if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
|
|
while (Module['preInit'].length > 0) {
|
|
Module['preInit'].pop()();
|
|
}
|
|
}
|
|
|
|
// shouldRunNow refers to calling main(), not run().
|
|
var shouldRunNow = true;
|
|
|
|
if (Module['noInitialRun']) shouldRunNow = false;
|
|
|
|
|
|
if (!ENVIRONMENT_IS_PTHREAD) // EXIT_RUNTIME=0 only applies to default behavior of the main browser thread
|
|
noExitRuntime = true;
|
|
|
|
if (!ENVIRONMENT_IS_PTHREAD) run();
|
|
|
|
|
|
|
|
|
|
|
|
// {{MODULE_ADDITIONS}}
|
|
|
|
|
|
|