| |
| var liblouisBuild = (function() { |
| var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; |
| if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename; |
| return ( |
| function(liblouisBuild) { |
| liblouisBuild = liblouisBuild || {}; |
| |
| // 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 liblouisBuild !== 'undefined' ? liblouisBuild : {}; |
| |
| // --pre-jses are emitted after the Module integration code, so that they can |
| // refer to Module (if they choose; they can also define Module) |
| |
| if (!Module.expectedDataFileDownloads) { |
| Module.expectedDataFileDownloads = 0; |
| Module.finishedDataFileDownloads = 0; |
| } |
| Module.expectedDataFileDownloads++; |
| (function() { |
| var loadPackage = function(metadata) { |
| |
| var PACKAGE_PATH; |
| if (typeof window === 'object') { |
| PACKAGE_PATH = window['encodeURIComponent'](window.location.pathname.toString().substring(0, window.location.pathname.toString().lastIndexOf('/')) + '/'); |
| } else if (typeof location !== 'undefined') { |
| // worker |
| PACKAGE_PATH = encodeURIComponent(location.pathname.toString().substring(0, location.pathname.toString().lastIndexOf('/')) + '/'); |
| } else { |
| throw 'using preloaded data can only be done on a web page or in a web worker'; |
| } |
| var PACKAGE_NAME = 'liblouis_wasm.data'; |
| var REMOTE_PACKAGE_BASE = 'liblouis_wasm.data'; |
| if (typeof Module['locateFilePackage'] === 'function' && !Module['locateFile']) { |
| Module['locateFile'] = Module['locateFilePackage']; |
| err('warning: you defined Module.locateFilePackage, that has been renamed to Module.locateFile (using your locateFilePackage for now)'); |
| } |
| var REMOTE_PACKAGE_NAME = Module['locateFile'] ? Module['locateFile'](REMOTE_PACKAGE_BASE, '') : REMOTE_PACKAGE_BASE; |
| |
| var REMOTE_PACKAGE_SIZE = metadata.remote_package_size; |
| var PACKAGE_UUID = metadata.package_uuid; |
| |
| function fetchRemotePackage(packageName, packageSize, callback, errback) { |
| var xhr = new XMLHttpRequest(); |
| xhr.open('GET', packageName, true); |
| xhr.responseType = 'arraybuffer'; |
| xhr.onprogress = function(event) { |
| var url = packageName; |
| var size = packageSize; |
| if (event.total) size = event.total; |
| if (event.loaded) { |
| if (!xhr.addedTotal) { |
| xhr.addedTotal = true; |
| if (!Module.dataFileDownloads) Module.dataFileDownloads = {}; |
| Module.dataFileDownloads[url] = { |
| loaded: event.loaded, |
| total: size |
| }; |
| } else { |
| Module.dataFileDownloads[url].loaded = event.loaded; |
| } |
| var total = 0; |
| var loaded = 0; |
| var num = 0; |
| for (var download in Module.dataFileDownloads) { |
| var data = Module.dataFileDownloads[download]; |
| total += data.total; |
| loaded += data.loaded; |
| num++; |
| } |
| total = Math.ceil(total * Module.expectedDataFileDownloads/num); |
| if (Module['setStatus']) Module['setStatus']('Downloading data... (' + loaded + '/' + total + ')'); |
| } else if (!Module.dataFileDownloads) { |
| if (Module['setStatus']) Module['setStatus']('Downloading data...'); |
| } |
| }; |
| xhr.onerror = function(event) { |
| throw new Error("NetworkError for: " + packageName); |
| } |
| xhr.onload = function(event) { |
| if (xhr.status == 200 || xhr.status == 304 || xhr.status == 206 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 |
| var packageData = xhr.response; |
| callback(packageData); |
| } else { |
| throw new Error(xhr.statusText + " : " + xhr.responseURL); |
| } |
| }; |
| xhr.send(null); |
| }; |
| |
| function handleError(error) { |
| console.error('package error:', error); |
| }; |
| |
| var fetchedCallback = null; |
| var fetched = Module['getPreloadedPackage'] ? Module['getPreloadedPackage'](REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE) : null; |
| |
| if (!fetched) fetchRemotePackage(REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE, function(data) { |
| if (fetchedCallback) { |
| fetchedCallback(data); |
| fetchedCallback = null; |
| } else { |
| fetched = data; |
| } |
| }, handleError); |
| |
| function runWithFS() { |
| |
| function assert(check, msg) { |
| if (!check) throw msg + new Error().stack; |
| } |
| |
| function DataRequest(start, end, audio) { |
| this.start = start; |
| this.end = end; |
| this.audio = audio; |
| } |
| DataRequest.prototype = { |
| requests: {}, |
| open: function(mode, name) { |
| this.name = name; |
| this.requests[name] = this; |
| Module['addRunDependency']('fp ' + this.name); |
| }, |
| send: function() {}, |
| onload: function() { |
| var byteArray = this.byteArray.subarray(this.start, this.end); |
| this.finish(byteArray); |
| }, |
| finish: function(byteArray) { |
| var that = this; |
| |
| Module['FS_createDataFile'](this.name, null, byteArray, true, true, true); // canOwn this data in the filesystem, it is a slide into the heap that will never change |
| Module['removeRunDependency']('fp ' + that.name); |
| |
| this.requests[this.name] = null; |
| } |
| }; |
| |
| var files = metadata.files; |
| for (var i = 0; i < files.length; ++i) { |
| new DataRequest(files[i].start, files[i].end, files[i].audio).open('GET', files[i].filename); |
| } |
| |
| |
| function processPackageData(arrayBuffer) { |
| Module.finishedDataFileDownloads++; |
| assert(arrayBuffer, 'Loading data file failed.'); |
| assert(arrayBuffer instanceof ArrayBuffer, 'bad input to processPackageData'); |
| var byteArray = new Uint8Array(arrayBuffer); |
| var curr; |
| |
| // copy the entire loaded file into a spot in the heap. Files will refer to slices in that. They cannot be freed though |
| // (we may be allocating before malloc is ready, during startup). |
| var ptr = Module['getMemory'](byteArray.length); |
| Module['HEAPU8'].set(byteArray, ptr); |
| DataRequest.prototype.byteArray = Module['HEAPU8'].subarray(ptr, ptr+byteArray.length); |
| |
| var files = metadata.files; |
| for (var i = 0; i < files.length; ++i) { |
| DataRequest.prototype.requests[files[i].filename].onload(); |
| } |
| Module['removeRunDependency']('datafile_liblouis_wasm.data'); |
| |
| }; |
| Module['addRunDependency']('datafile_liblouis_wasm.data'); |
| |
| if (!Module.preloadResults) Module.preloadResults = {}; |
| |
| Module.preloadResults[PACKAGE_NAME] = {fromCache: false}; |
| if (fetched) { |
| processPackageData(fetched); |
| fetched = null; |
| } else { |
| fetchedCallback = processPackageData; |
| } |
| |
| } |
| if (Module['calledRun']) { |
| runWithFS(); |
| } else { |
| if (!Module['preRun']) Module['preRun'] = []; |
| Module["preRun"].push(runWithFS); // FS is not initialized yet, wait for it |
| } |
| |
| } |
| loadPackage({"files": [{"start": 0, "audio": 0, "end": 7510, "filename": "/pt-pt-g1.utb"}, {"start": 7510, "audio": 0, "end": 15360, "filename": "/ar-ar-comp8.utb"}, {"start": 15360, "audio": 0, "end": 44841, "filename": "/de-g2-core.cti"}, {"start": 44841, "audio": 0, "end": 46330, "filename": "/de-chess.ctb"}, {"start": 46330, "audio": 0, "end": 58848, "filename": "/cy-cy-g1.utb"}, {"start": 58848, "audio": 0, "end": 75152, "filename": "/grc-international-composed.uti"}, {"start": 75152, "audio": 0, "end": 107958, "filename": "/no-no-latinLetterDef6Dots_diacritics.uti"}, {"start": 107958, "audio": 0, "end": 115769, "filename": "/fi.utb"}, {"start": 115769, "audio": 0, "end": 121444, "filename": "/fa-ir-g1.utb"}, {"start": 121444, "audio": 0, "end": 121970, "filename": "/cs.tbl"}, {"start": 121970, "audio": 0, "end": 135614, "filename": "/no-no.dis"}, {"start": 135614, "audio": 0, "end": 153833, "filename": "/Lv-Lv-g1.utb"}, {"start": 153833, "audio": 0, "end": 162602, "filename": "/sl-si-comp8.ctb"}, {"start": 162602, "audio": 0, "end": 171940, "filename": "/de-de-comp8.ctb"}, {"start": 171940, "audio": 0, "end": 172516, "filename": "/hy.tbl"}, {"start": 172516, "audio": 0, "end": 174293, "filename": "/ko-2006-g1.ctb"}, {"start": 174293, "audio": 0, "end": 183685, "filename": "/ar-ar-g1.utb"}, {"start": 183685, "audio": 0, "end": 1446222, "filename": "/zh-chn.ctb"}, {"start": 1446222, "audio": 0, "end": 1446796, "filename": "/vi.tbl"}, {"start": 1446796, "audio": 0, "end": 1449169, "filename": "/mn-MN-common.cti"}, {"start": 1449169, "audio": 0, "end": 1450457, "filename": "/hyph_pt_PT.dic"}, {"start": 1450457, "audio": 0, "end": 1451021, "filename": "/sa.tbl"}, {"start": 1451021, "audio": 0, "end": 1451584, "filename": "/eo.tbl"}, {"start": 1451584, "audio": 0, "end": 1452184, "filename": "/cy.tbl"}, {"start": 1452184, "audio": 0, "end": 1453165, "filename": "/litdigits6DotsPlusDot6.uti"}, {"start": 1453165, "audio": 0, "end": 1458765, "filename": "/ko.cti"}, {"start": 1458765, "audio": 0, "end": 1459687, "filename": "/mun.ctb"}, {"start": 1459687, "audio": 0, "end": 1460291, "filename": "/ar.tbl"}, {"start": 1460291, "audio": 0, "end": 1460437, "filename": "/hr-g1.tbl"}, {"start": 1460437, "audio": 0, "end": 1462822, "filename": "/de-accents-detailed.cti"}, {"start": 1462822, "audio": 0, "end": 1465781, "filename": "/eo-g1-x-system.ctb"}, {"start": 1465781, "audio": 0, "end": 1480141, "filename": "/fr-bfu-comp8.utb"}, {"start": 1480141, "audio": 0, "end": 1480704, "filename": "/ru.tbl"}, {"start": 1480704, "audio": 0, "end": 1482903, "filename": "/de-eurobrl6.dis"}, {"start": 1482903, "audio": 0, "end": 1525141, "filename": "/Makefile.in"}, {"start": 1525141, "audio": 0, "end": 1529772, "filename": "/en-us-comp6.ctb"}, {"start": 1529772, "audio": 0, "end": 1591170, "filename": "/hyph_da_DK.dic"}, {"start": 1591170, "audio": 0, "end": 1592386, "filename": "/mn-in-g1.utb"}, {"start": 1592386, "audio": 0, "end": 1614417, "filename": "/sk-chardefs.cti"}, {"start": 1614417, "audio": 0, "end": 1617779, "filename": "/hu-hu-g1_braille_input.cti"}, {"start": 1617779, "audio": 0, "end": 2493883, "filename": "/hyph_hu_HU.dic"}, {"start": 2493883, "audio": 0, "end": 2494566, "filename": "/en_US.tbl"}, {"start": 2494566, "audio": 0, "end": 2519399, "filename": "/unicode-braille.utb"}, {"start": 2519399, "audio": 0, "end": 3956728, "filename": "/zh-tw.ctb"}, {"start": 3956728, "audio": 0, "end": 3957318, "filename": "/gd.tbl"}, {"start": 3957318, "audio": 0, "end": 3957617, "filename": "/no.tbl"}, {"start": 3957617, "audio": 0, "end": 3958161, "filename": "/mun.tbl"}, {"start": 3958161, "audio": 0, "end": 3958430, "filename": "/en_US-comp8-ext.tbl"}, {"start": 3958430, "audio": 0, "end": 3969652, "filename": "/malayalam.cti"}, {"start": 3969652, "audio": 0, "end": 3970578, "filename": "/kru.ctb"}, {"start": 3970578, "audio": 0, "end": 3994259, "filename": "/ko-g1-rules.cti"}, {"start": 3994259, "audio": 0, "end": 3994864, "filename": "/cvox-common.cti"}, {"start": 3994864, "audio": 0, "end": 4005828, "filename": "/sin.cti"}, {"start": 4005828, "audio": 0, "end": 4013434, "filename": "/cs-comp8.utb"}, {"start": 4013434, "audio": 0, "end": 4027736, "filename": "/cs-chardefs.cti"}, {"start": 4027736, "audio": 0, "end": 4028314, "filename": "/bg.tbl"}, {"start": 4028314, "audio": 0, "end": 4064781, "filename": "/hyph_en_US.dic"}, {"start": 4064781, "audio": 0, "end": 4071740, "filename": "/vi-g1.ctb"}, {"start": 4071740, "audio": 0, "end": 4258418, "filename": "/hyph_nn_NO.dic"}, {"start": 4258418, "audio": 0, "end": 4282205, "filename": "/en-us-comp8-ext.utb"}, {"start": 4282205, "audio": 0, "end": 4298532, "filename": "/de-chardefs6.cti"}, {"start": 4298532, "audio": 0, "end": 4311433, "filename": "/no-no-g2.ctb"}, {"start": 4311433, "audio": 0, "end": 4312498, "filename": "/digits6DotsPlusDot6.uti"}, {"start": 4312498, "audio": 0, "end": 4313853, "filename": "/sin.utb"}, {"start": 4313853, "audio": 0, "end": 4323486, "filename": "/de-accents.cti"}, {"start": 4323486, "audio": 0, "end": 4324703, "filename": "/gu-in-g1.utb"}, {"start": 4324703, "audio": 0, "end": 4326146, "filename": "/hr-digits.uti"}, {"start": 4326146, "audio": 0, "end": 4336892, "filename": "/no-no-chardefs6.uti"}, {"start": 4336892, "audio": 0, "end": 4352441, "filename": "/ukmaths_unicode_defs.cti"}, {"start": 4352441, "audio": 0, "end": 4353861, "filename": "/latinLetterDef6Dots.uti"}, {"start": 4353861, "audio": 0, "end": 4379353, "filename": "/el.ctb"}, {"start": 4379353, "audio": 0, "end": 4379912, "filename": "/ca.tbl"}, {"start": 4379912, "audio": 0, "end": 4383138, "filename": "/ga-g1.utb"}, {"start": 4383138, "audio": 0, "end": 4393505, "filename": "/bengali.cti"}, {"start": 4393505, "audio": 0, "end": 4394042, "filename": "/sl.tbl"}, {"start": 4394042, "audio": 0, "end": 4410014, "filename": "/hr-chardefs.cti"}, {"start": 4410014, "audio": 0, "end": 4410594, "filename": "/dra.tbl"}, {"start": 4410594, "audio": 0, "end": 4411158, "filename": "/gu.tbl"}, {"start": 4411158, "audio": 0, "end": 4426648, "filename": "/gr-pl-comp8.uti"}, {"start": 4426648, "audio": 0, "end": 4427572, "filename": "/pi.ctb"}, {"start": 4427572, "audio": 0, "end": 4464375, "filename": "/Makefile"}, {"start": 4464375, "audio": 0, "end": 4484456, "filename": "/nl-chardefs.uti"}, {"start": 4484456, "audio": 0, "end": 4485021, "filename": "/gez.tbl"}, {"start": 4485021, "audio": 0, "end": 4492137, "filename": "/ethio-g1.ctb"}, {"start": 4492137, "audio": 0, "end": 4496354, "filename": "/hyph_es_ES.dic"}, {"start": 4496354, "audio": 0, "end": 4496916, "filename": "/mr.tbl"}, {"start": 4496916, "audio": 0, "end": 4498961, "filename": "/en-ueb-math.ctb"}, {"start": 4498961, "audio": 0, "end": 4513374, "filename": "/da-dk-g26l.ctb"}, {"start": 4513374, "audio": 0, "end": 4520674, "filename": "/IPA.utb"}, {"start": 4520674, "audio": 0, "end": 4522816, "filename": "/no-no-8dot-fallback-6dot-g0.utb"}, {"start": 4522816, "audio": 0, "end": 4524033, "filename": "/np-in-g1.utb"}, {"start": 4524033, "audio": 0, "end": 4524951, "filename": "/digits6Dots.uti"}, {"start": 4524951, "audio": 0, "end": 4526820, "filename": "/ko-2006-g2.ctb"}, {"start": 4526820, "audio": 0, "end": 4554750, "filename": "/en-us-g2.ctb"}, {"start": 4554750, "audio": 0, "end": 4555655, "filename": "/dra.ctb"}, {"start": 4555655, "audio": 0, "end": 4561431, "filename": "/nl-comp8.utb"}, {"start": 4561431, "audio": 0, "end": 4564274, "filename": "/ru-letters.dis"}, {"start": 4564274, "audio": 0, "end": 4564814, "filename": "/pi.tbl"}, {"start": 4564814, "audio": 0, "end": 4573620, "filename": "/nl-NL-g0.utb"}, {"start": 4573620, "audio": 0, "end": 4598308, "filename": "/de-g0-core.uti"}, {"start": 4598308, "audio": 0, "end": 4601060, "filename": "/ru-unicode.dis"}, {"start": 4601060, "audio": 0, "end": 4606486, "filename": "/hy.ctb"}, {"start": 4606486, "audio": 0, "end": 4607060, "filename": "/tr.tbl"}, {"start": 4607060, "audio": 0, "end": 4610136, "filename": "/uk.utb"}, {"start": 4610136, "audio": 0, "end": 4613609, "filename": "/grc-international-common.uti"}, {"start": 4613609, "audio": 0, "end": 4616987, "filename": "/afr-za-g1.ctb"}, {"start": 4616987, "audio": 0, "end": 4620319, "filename": "/sr-g1.ctb"}, {"start": 4620319, "audio": 0, "end": 4627951, "filename": "/sv-1996.ctb"}, {"start": 4627951, "audio": 0, "end": 4630090, "filename": "/en-gb-comp8.ctb"}, {"start": 4630090, "audio": 0, "end": 4632695, "filename": "/sk-translation.cti"}, {"start": 4632695, "audio": 0, "end": 4633254, "filename": "/sr.tbl"}, {"start": 4633254, "audio": 0, "end": 4644747, "filename": "/lt-6dot.utb"}, {"start": 4644747, "audio": 0, "end": 4654287, "filename": "/Pl-Pl-g1.utb"}, {"start": 4654287, "audio": 0, "end": 4662310, "filename": "/da-dk-g16.ctb"}, {"start": 4662310, "audio": 0, "end": 4694921, "filename": "/hu-hu-g2_exceptions.cti"}, {"start": 4694921, "audio": 0, "end": 4778446, "filename": "/hyph_nl_NL.dic"}, {"start": 4778446, "audio": 0, "end": 4786904, "filename": "/hr-translation.cti"}, {"start": 4786904, "audio": 0, "end": 4787468, "filename": "/as.tbl"}, {"start": 4787468, "audio": 0, "end": 4794524, "filename": "/he.ctb"}, {"start": 4794524, "audio": 0, "end": 4796358, "filename": "/printables.cti"}, {"start": 4796358, "audio": 0, "end": 4797037, "filename": "/en_GB.tbl"}, {"start": 4797037, "audio": 0, "end": 4799050, "filename": "/ru-chardefs.cti"}, {"start": 4799050, "audio": 0, "end": 4809148, "filename": "/ar-ar-g2.ctb"}, {"start": 4809148, "audio": 0, "end": 4822673, "filename": "/da-dk-g08.ctb"}, {"start": 4822673, "audio": 0, "end": 4829936, "filename": "/en-nabcc.utb"}, {"start": 4829936, "audio": 0, "end": 4831173, "filename": "/es-g1.ctb"}, {"start": 4831173, "audio": 0, "end": 4832829, "filename": "/nl-BE.dis"}, {"start": 4832829, "audio": 0, "end": 4852879, "filename": "/no-no-8dot.utb"}, {"start": 4852879, "audio": 0, "end": 4853897, "filename": "/maketablelist.sh"}, {"start": 4853897, "audio": 0, "end": 4862001, "filename": "/en_CA.ctb"}, {"start": 4862001, "audio": 0, "end": 4873702, "filename": "/hu-chardefs.cti"}, {"start": 4873702, "audio": 0, "end": 4874250, "filename": "/mwr.tbl"}, {"start": 4874250, "audio": 0, "end": 4875011, "filename": "/zh_CHN.tbl"}, {"start": 4875011, "audio": 0, "end": 4919193, "filename": "/ur-pk-g2.ctb"}, {"start": 4919193, "audio": 0, "end": 4928476, "filename": "/en-ueb-g1.ctb"}, {"start": 4928476, "audio": 0, "end": 4936786, "filename": "/nl-BE-g0.utb"}, {"start": 4936786, "audio": 0, "end": 4937713, "filename": "/kok.ctb"}, {"start": 4937713, "audio": 0, "end": 4945778, "filename": "/iu-ca-g1.ctb"}, {"start": 4945778, "audio": 0, "end": 4946996, "filename": "/mr-in-g1.utb"}, {"start": 4946996, "audio": 0, "end": 5133674, "filename": "/hyph_nb_NO.dic"}, {"start": 5133674, "audio": 0, "end": 5134284, "filename": "/pt.tbl"}, {"start": 5134284, "audio": 0, "end": 5139004, "filename": "/grc-international-en.utb"}, {"start": 5139004, "audio": 0, "end": 5140825, "filename": "/mn-MN-g2.ctb"}, {"start": 5140825, "audio": 0, "end": 5142036, "filename": "/or-in-g1.utb"}, {"start": 5142036, "audio": 0, "end": 5151564, "filename": "/oriya.cti"}, {"start": 5151564, "audio": 0, "end": 5153096, "filename": "/ukmaths_single_cell_defs.cti"}, {"start": 5153096, "audio": 0, "end": 5164729, "filename": "/da-lt.ctb"}, {"start": 5164729, "audio": 0, "end": 5165290, "filename": "/awa.tbl"}, {"start": 5165290, "audio": 0, "end": 5174786, "filename": "/sv-1989.ctb"}, {"start": 5174786, "audio": 0, "end": 5176001, "filename": "/be-in-g1.utb"}, {"start": 5176001, "audio": 0, "end": 5176633, "filename": "/nl.tbl"}, {"start": 5176633, "audio": 0, "end": 5177850, "filename": "/si-in-g1.utb"}, {"start": 5177850, "audio": 0, "end": 5181068, "filename": "/tamil.cti"}, {"start": 5181068, "audio": 0, "end": 5195313, "filename": "/da-dk-g26l-lit.ctb"}, {"start": 5195313, "audio": 0, "end": 5197685, "filename": "/sk-sk.utb"}, {"start": 5197685, "audio": 0, "end": 5198229, "filename": "/bh.tbl"}, {"start": 5198229, "audio": 0, "end": 5202712, "filename": "/en-us-g1.ctb"}, {"start": 5202712, "audio": 0, "end": 5203278, "filename": "/ml.tbl"}, {"start": 5203278, "audio": 0, "end": 5208043, "filename": "/Se-Se-g1.utb"}, {"start": 5208043, "audio": 0, "end": 5210481, "filename": "/en-us-brf.dis"}, {"start": 5210481, "audio": 0, "end": 5236014, "filename": "/es-g2.ctb"}, {"start": 5236014, "audio": 0, "end": 5237646, "filename": "/en-us-comp8.ctb"}, {"start": 5237646, "audio": 0, "end": 5245747, "filename": "/en-chardefs.cti"}, {"start": 5245747, "audio": 0, "end": 5247865, "filename": "/tr-g1.ctb"}, {"start": 5247865, "audio": 0, "end": 5249081, "filename": "/pu-in-g1.utb"}, {"start": 5249081, "audio": 0, "end": 5265915, "filename": "/lt.ctb"}, {"start": 5265915, "audio": 0, "end": 5266538, "filename": "/nl_BE.tbl"}, {"start": 5266538, "audio": 0, "end": 5267757, "filename": "/sa-in-g1.utb"}, {"start": 5267757, "audio": 0, "end": 5268976, "filename": "/ks-in-g1.utb"}, {"start": 5268976, "audio": 0, "end": 5273671, "filename": "/hu-hu-comp8.ctb"}, {"start": 5273671, "audio": 0, "end": 5289219, "filename": "/marburg_unicode_defs.cti"}, {"start": 5289219, "audio": 0, "end": 5293894, "filename": "/ga-g2.ctb"}, {"start": 5293894, "audio": 0, "end": 5558155, "filename": "/zh-hk.ctb"}, {"start": 5558155, "audio": 0, "end": 5558712, "filename": "/sk.tbl"}, {"start": 5558712, "audio": 0, "end": 6234646, "filename": "/zhcn-g1.ctb"}, {"start": 6234646, "audio": 0, "end": 6235222, "filename": "/et.tbl"}, {"start": 6235222, "audio": 0, "end": 6264269, "filename": "/afr-za-g2.ctb"}, {"start": 6264269, "audio": 0, "end": 6265461, "filename": "/kh-in-g1.utb"}, {"start": 6265461, "audio": 0, "end": 6270370, "filename": "/hu-hu-g1.ctb"}, {"start": 6270370, "audio": 0, "end": 6271868, "filename": "/en-chess.ctb"}, {"start": 6271868, "audio": 0, "end": 6272183, "filename": "/zh_HK.tbl"}, {"start": 6272183, "audio": 0, "end": 6272753, "filename": "/ta.tbl"}, {"start": 6272753, "audio": 0, "end": 6273310, "filename": "/bra.tbl"}, {"start": 6273310, "audio": 0, "end": 6287483, "filename": "/no-no-generic.dis"}, {"start": 6287483, "audio": 0, "end": 6288043, "filename": "/ne.tbl"}, {"start": 6288043, "audio": 0, "end": 6293051, "filename": "/ro.ctb"}, {"start": 6293051, "audio": 0, "end": 6294516, "filename": "/haw-us-g1.ctb"}, {"start": 6294516, "audio": 0, "end": 6296683, "filename": "/en-us-compbrl.uti"}, {"start": 6296683, "audio": 0, "end": 6298057, "filename": "/de-g2.ctb"}, {"start": 6298057, "audio": 0, "end": 6298618, "filename": "/ckb.tbl"}, {"start": 6298618, "audio": 0, "end": 6299834, "filename": "/hi-in-g1.utb"}, {"start": 6299834, "audio": 0, "end": 6313094, "filename": "/sl-si-g1.utb"}, {"start": 6313094, "audio": 0, "end": 6339525, "filename": "/braille-patterns.cti"}, {"start": 6339525, "audio": 0, "end": 6359523, "filename": "/de-chardefs8.cti"}, {"start": 6359523, "audio": 0, "end": 6360083, "filename": "/sd.tbl"}, {"start": 6360083, "audio": 0, "end": 6365539, "filename": "/chr-us-g1.ctb"}, {"start": 6365539, "audio": 0, "end": 6372787, "filename": "/bo.ctb"}, {"start": 6372787, "audio": 0, "end": 6372953, "filename": "/lt-6dot.tbl"}, {"start": 6372953, "audio": 0, "end": 6386141, "filename": "/IPA-unicode-range.uti"}, {"start": 6386141, "audio": 0, "end": 6389682, "filename": "/ckb-translation.cti"}, {"start": 6389682, "audio": 0, "end": 6397742, "filename": "/da-dk-g16-lit.ctb"}, {"start": 6397742, "audio": 0, "end": 6398288, "filename": "/kru.tbl"}, {"start": 6398288, "audio": 0, "end": 6399707, "filename": "/compress.cti"}, {"start": 6399707, "audio": 0, "end": 6400664, "filename": "/litdigits6Dots.uti"}, {"start": 6400664, "audio": 0, "end": 6414382, "filename": "/da-dk-6miscChars.cti"}, {"start": 6414382, "audio": 0, "end": 6418688, "filename": "/cy-cy-g2.ctb"}, {"start": 6418688, "audio": 0, "end": 6423977, "filename": "/gd.ctb"}, {"start": 6423977, "audio": 0, "end": 6434644, "filename": "/hyph_eo.dic"}, {"start": 6434644, "audio": 0, "end": 6435621, "filename": "/ca-g1.ctb"}, {"start": 6435621, "audio": 0, "end": 6440952, "filename": "/cs-letterDef8Dots.uti"}, {"start": 6440952, "audio": 0, "end": 6442777, "filename": "/mn-MN-g1.utb"}, {"start": 6442777, "audio": 0, "end": 6451208, "filename": "/fi-fi-8dot.ctb"}, {"start": 6451208, "audio": 0, "end": 6457638, "filename": "/bg.ctb"}, {"start": 6457638, "audio": 0, "end": 6458269, "filename": "/hu.tbl"}, {"start": 6458269, "audio": 0, "end": 6469946, "filename": "/fr-bfu-comp6.utb"}, {"start": 6469946, "audio": 0, "end": 6484562, "filename": "/uni-text.dis"}, {"start": 6484562, "audio": 0, "end": 6502418, "filename": "/pl-pl-comp8.ctb"}, {"start": 6502418, "audio": 0, "end": 6503362, "filename": "/gon.ctb"}, {"start": 6503362, "audio": 0, "end": 6517963, "filename": "/de-de.dis"}, {"start": 6517963, "audio": 0, "end": 6548514, "filename": "/hyph_pl_PL.dic"}, {"start": 6548514, "audio": 0, "end": 6549559, "filename": "/controlchars.cti"}, {"start": 6549559, "audio": 0, "end": 6550957, "filename": "/latinLetterDef8Dots.uti"}, {"start": 6550957, "audio": 0, "end": 6551531, "filename": "/mt.tbl"}, {"start": 6551531, "audio": 0, "end": 6552572, "filename": "/sot-za-g1.ctb"}, {"start": 6552572, "audio": 0, "end": 6567265, "filename": "/se-se.dis"}, {"start": 6567265, "audio": 0, "end": 6580393, "filename": "/hu-hu-g2.ctb"}, {"start": 6580393, "audio": 0, "end": 6580953, "filename": "/pl.tbl"}, {"start": 6580953, "audio": 0, "end": 6592986, "filename": "/vi.ctb"}, {"start": 6592986, "audio": 0, "end": 6603503, "filename": "/hr-comp8.utb"}, {"start": 6603503, "audio": 0, "end": 6604857, "filename": "/cs-g1.ctb"}, {"start": 6604857, "audio": 0, "end": 6606647, "filename": "/ko-g2.ctb"}, {"start": 6606647, "audio": 0, "end": 6611848, "filename": "/sk-sk-g1.utb"}, {"start": 6611848, "audio": 0, "end": 6620551, "filename": "/kannada.cti"}, {"start": 6620551, "audio": 0, "end": 6632062, "filename": "/fi2.ctb"}, {"start": 6632062, "audio": 0, "end": 6776406, "filename": "/fr-bfu-g2.ctb"}, {"start": 6776406, "audio": 0, "end": 6776968, "filename": "/kn.tbl"}, {"start": 6776968, "audio": 0, "end": 6813063, "filename": "/de-g1-core-patterns.dic"}, {"start": 6813063, "audio": 0, "end": 6813654, "filename": "/lt.tbl"}, {"start": 6813654, "audio": 0, "end": 6820084, "filename": "/nl-g0.uti"}, {"start": 6820084, "audio": 0, "end": 6829689, "filename": "/gujarati.cti"}, {"start": 6829689, "audio": 0, "end": 6839930, "filename": "/se-se.ctb"}, {"start": 6839930, "audio": 0, "end": 6840492, "filename": "/sv.tbl"}, {"start": 6840492, "audio": 0, "end": 6840814, "filename": "/zh_TW.tbl"}, {"start": 6840814, "audio": 0, "end": 6841740, "filename": "/loweredDigits6Dots.uti"}, {"start": 6841740, "audio": 0, "end": 6862188, "filename": "/en-us-mathtext.ctb"}, {"start": 6862188, "audio": 0, "end": 6863398, "filename": "/ckb-g1.ctb"}, {"start": 6863398, "audio": 0, "end": 6864334, "filename": "/loweredDigits8Dots.uti"}, {"start": 6864334, "audio": 0, "end": 6864908, "filename": "/bo.tbl"}, {"start": 6864908, "audio": 0, "end": 6876993, "filename": "/fr-bfu-comp68.cti"}, {"start": 6876993, "audio": 0, "end": 6878503, "filename": "/hr-g1.ctb"}, {"start": 6878503, "audio": 0, "end": 6884834, "filename": "/no-no-g0.utb"}, {"start": 6884834, "audio": 0, "end": 6896170, "filename": "/ru.ctb"}, {"start": 6896170, "audio": 0, "end": 6900024, "filename": "/wordcx.dis"}, {"start": 6900024, "audio": 0, "end": 6900916, "filename": "/ne.ctb"}, {"start": 6900916, "audio": 0, "end": 6907797, "filename": "/sr-chardefs.cti"}, {"start": 6907797, "audio": 0, "end": 6911756, "filename": "/ko-2006.cti"}, {"start": 6911756, "audio": 0, "end": 6932998, "filename": "/is-chardefs8.cti"}, {"start": 6932998, "audio": 0, "end": 6952486, "filename": "/en-ueb-chardefs.uti"}, {"start": 6952486, "audio": 0, "end": 6953062, "filename": "/ro.tbl"}, {"start": 6953062, "audio": 0, "end": 6981635, "filename": "/da-dk-g26.ctb"}, {"start": 6981635, "audio": 0, "end": 6986809, "filename": "/fa-ir-comp8.ctb"}, {"start": 6986809, "audio": 0, "end": 7007605, "filename": "/no-no-comp8.ctb"}, {"start": 7007605, "audio": 0, "end": 7009120, "filename": "/marburg_single_cell_defs.cti"}, {"start": 7009120, "audio": 0, "end": 7025566, "filename": "/grc-international-decomposed.uti"}, {"start": 7025566, "audio": 0, "end": 7025727, "filename": "/README"}, {"start": 7025727, "audio": 0, "end": 7042223, "filename": "/nemethdefs.cti"}, {"start": 7042223, "audio": 0, "end": 7063966, "filename": "/hyph_cs_CZ.dic"}, {"start": 7063966, "audio": 0, "end": 7069002, "filename": "/et-g0.utb"}, {"start": 7069002, "audio": 0, "end": 7079307, "filename": "/boxes.ctb"}, {"start": 7079307, "audio": 0, "end": 7079869, "filename": "/bn.tbl"}, {"start": 7079869, "audio": 0, "end": 7080475, "filename": "/en_CA.tbl"}, {"start": 7080475, "audio": 0, "end": 7081401, "filename": "/bh.ctb"}, {"start": 7081401, "audio": 0, "end": 7082329, "filename": "/digits8Dots.uti"}, {"start": 7082329, "audio": 0, "end": 7464677, "filename": "/ko-chars.cti"}, {"start": 7464677, "audio": 0, "end": 7465896, "filename": "/ml-in-g1.utb"}, {"start": 7465896, "audio": 0, "end": 7473038, "filename": "/is-chardefs6.cti"}, {"start": 7473038, "audio": 0, "end": 7514824, "filename": "/da-dk-g28.ctb"}, {"start": 7514824, "audio": 0, "end": 7516316, "filename": "/corrections.cti"}, {"start": 7516316, "audio": 0, "end": 7545049, "filename": "/it-it-comp8.utb"}, {"start": 7545049, "audio": 0, "end": 7566609, "filename": "/pt-pt-g2.ctb"}, {"start": 7566609, "audio": 0, "end": 7578184, "filename": "/da-dk-octobraille.dis"}, {"start": 7578184, "audio": 0, "end": 7579746, "filename": "/us-table.dis"}, {"start": 7579746, "audio": 0, "end": 7587970, "filename": "/ru-ru.dis"}, {"start": 7587970, "audio": 0, "end": 7588552, "filename": "/hr-comp8.tbl"}, {"start": 7588552, "audio": 0, "end": 7589767, "filename": "/ka-in-g1.utb"}, {"start": 7589767, "audio": 0, "end": 7590325, "filename": "/or.tbl"}, {"start": 7590325, "audio": 0, "end": 7590885, "filename": "/te.tbl"}, {"start": 7590885, "audio": 0, "end": 7622144, "filename": "/hyph_sv_SE.dic"}, {"start": 7622144, "audio": 0, "end": 7622713, "filename": "/is.tbl"}, {"start": 7622713, "audio": 0, "end": 7623926, "filename": "/te-in-g1.utb"}, {"start": 7623926, "audio": 0, "end": 7898702, "filename": "/ko-g2-rules.cti"}, {"start": 7898702, "audio": 0, "end": 7902807, "filename": "/et.ctb"}, {"start": 7902807, "audio": 0, "end": 7911370, "filename": "/ckb-chardefs.cti"}, {"start": 7911370, "audio": 0, "end": 8528721, "filename": "/zhcn-g2.ctb"}, {"start": 8528721, "audio": 0, "end": 8548562, "filename": "/da-dk-g26-lit.ctb"}, {"start": 8548562, "audio": 0, "end": 8549106, "filename": "/gon.tbl"}, {"start": 8549106, "audio": 0, "end": 8741674, "filename": "/de-g2-core-patterns.dic"}, {"start": 8741674, "audio": 0, "end": 8769739, "filename": "/en-us-interline.ctb"}, {"start": 8769739, "audio": 0, "end": 8806540, "filename": "/hyph_de_DE.dic"}, {"start": 8806540, "audio": 0, "end": 8807111, "filename": "/lv.tbl"}, {"start": 8807111, "audio": 0, "end": 8808803, "filename": "/ko-g1.ctb"}, {"start": 8808803, "audio": 0, "end": 8810019, "filename": "/as-in-g1.utb"}, {"start": 8810019, "audio": 0, "end": 8810584, "filename": "/mni.tbl"}, {"start": 8810584, "audio": 0, "end": 8812107, "filename": "/de-g1.ctb"}, {"start": 8812107, "audio": 0, "end": 9002258, "filename": "/en-ueb-g2.ctb"}, {"start": 9002258, "audio": 0, "end": 9009081, "filename": "/es-old.dis"}, {"start": 9009081, "audio": 0, "end": 9009653, "filename": "/he.tbl"}, {"start": 9009653, "audio": 0, "end": 9010869, "filename": "/aw-in-g1.utb"}, {"start": 9010869, "audio": 0, "end": 9021128, "filename": "/gurumuki.cti"}, {"start": 9021128, "audio": 0, "end": 9021690, "filename": "/pa.tbl"}, {"start": 9021690, "audio": 0, "end": 9025710, "filename": "/no-no-g1.ctb"}, {"start": 9025710, "audio": 0, "end": 9055858, "filename": "/da-dk-g28l.ctb"}, {"start": 9055858, "audio": 0, "end": 9068398, "filename": "/en-gb-g1.utb"}, {"start": 9068398, "audio": 0, "end": 9075227, "filename": "/es-new.dis"}, {"start": 9075227, "audio": 0, "end": 9077687, "filename": "/eo-g1.ctb"}, {"start": 9077687, "audio": 0, "end": 9081203, "filename": "/en-in-g1.ctb"}, {"start": 9081203, "audio": 0, "end": 9092736, "filename": "/ur-pk-g1.utb"}, {"start": 9092736, "audio": 0, "end": 9093339, "filename": "/es.tbl"}, {"start": 9093339, "audio": 0, "end": 9103490, "filename": "/telugu.cti"}, {"start": 9103490, "audio": 0, "end": 9113546, "filename": "/da-dk-8miscChars.cti"}, {"start": 9113546, "audio": 0, "end": 9114940, "filename": "/de-g1-core.cti"}, {"start": 9114940, "audio": 0, "end": 9117463, "filename": "/cs-translation.cti"}, {"start": 9117463, "audio": 0, "end": 9123664, "filename": "/Makefile.am"}, {"start": 9123664, "audio": 0, "end": 9143318, "filename": "/en-GB-g2.ctb"}, {"start": 9143318, "audio": 0, "end": 9143906, "filename": "/tr-g2.tbl"}, {"start": 9143906, "audio": 0, "end": 9149807, "filename": "/is.ctb"}, {"start": 9149807, "audio": 0, "end": 9151021, "filename": "/br-in-g1.utb"}, {"start": 9151021, "audio": 0, "end": 9153227, "filename": "/hyph_it_IT.dic"}, {"start": 9153227, "audio": 0, "end": 9155329, "filename": "/spaces.uti"}, {"start": 9155329, "audio": 0, "end": 9168807, "filename": "/no-no-generic.ctb"}, {"start": 9168807, "audio": 0, "end": 9171899, "filename": "/pt-pt-comp8.ctb"}, {"start": 9171899, "audio": 0, "end": 9179878, "filename": "/hyph_fr_FR.dic"}, {"start": 9179878, "audio": 0, "end": 9185085, "filename": "/ru-litbrl.ctb"}, {"start": 9185085, "audio": 0, "end": 9186440, "filename": "/hu-backtranslate-correction.dis"}, {"start": 9186440, "audio": 0, "end": 9253976, "filename": "/hyph_ru.dic"}, {"start": 9253976, "audio": 0, "end": 9272744, "filename": "/no-no-g3.ctb"}, {"start": 9272744, "audio": 0, "end": 9273302, "filename": "/hi.tbl"}, {"start": 9273302, "audio": 0, "end": 9274203, "filename": "/unicode-without-blank.dis"}, {"start": 9274203, "audio": 0, "end": 9282022, "filename": "/no-no-braillo-047-01.dis"}, {"start": 9282022, "audio": 0, "end": 9286703, "filename": "/tr.ctb"}, {"start": 9286703, "audio": 0, "end": 9291109, "filename": "/it-it-comp6.utb"}, {"start": 9291109, "audio": 0, "end": 9292736, "filename": "/de-g0.utb"}, {"start": 9292736, "audio": 0, "end": 9295782, "filename": "/eurodefs.cti"}, {"start": 9295782, "audio": 0, "end": 9310124, "filename": "/ca-chardefs.cti"}, {"start": 9310124, "audio": 0, "end": 9328683, "filename": "/wiskunde-chardefs.cti"}, {"start": 9328683, "audio": 0, "end": 9332726, "filename": "/ru-compbrl.ctb"}, {"start": 9332726, "audio": 0, "end": 9448679, "filename": "/hu-exceptionwords.cti"}, {"start": 9448679, "audio": 0, "end": 9455716, "filename": "/Es-Es-G0.utb"}, {"start": 9455716, "audio": 0, "end": 9457807, "filename": "/de-eurobrl6u.dis"}, {"start": 9457807, "audio": 0, "end": 9469301, "filename": "/fi1.ctb"}, {"start": 9469301, "audio": 0, "end": 9475275, "filename": "/unicode.dis"}, {"start": 9475275, "audio": 0, "end": 9479826, "filename": "/mt.ctb"}, {"start": 9479826, "audio": 0, "end": 9480753, "filename": "/mwr.ctb"}, {"start": 9480753, "audio": 0, "end": 9490052, "filename": "/devanagari.cti"}, {"start": 9490052, "audio": 0, "end": 9511702, "filename": "/text_nabcc.dis"}, {"start": 9511702, "audio": 0, "end": 9520005, "filename": "/da-dk.dis"}, {"start": 9520005, "audio": 0, "end": 9520564, "filename": "/kha.tbl"}, {"start": 9520564, "audio": 0, "end": 9533138, "filename": "/tr-g2.ctb"}, {"start": 9533138, "audio": 0, "end": 9536372, "filename": "/ukchardefs.cti"}, {"start": 9536372, "audio": 0, "end": 9550340, "filename": "/es-chardefs.cti"}, {"start": 9550340, "audio": 0, "end": 9551772, "filename": "/sk-g1.ctb"}, {"start": 9551772, "audio": 0, "end": 9558475, "filename": "/countries.cti"}, {"start": 9558475, "audio": 0, "end": 9569097, "filename": "/ru-ru-g1.utb"}, {"start": 9569097, "audio": 0, "end": 9569645, "filename": "/kok.tbl"}, {"start": 9569645, "audio": 0, "end": 9583735, "filename": "/da-dk-g18.ctb"}, {"start": 9583735, "audio": 0, "end": 9585417, "filename": "/mao-nz-g1.ctb"}, {"start": 9585417, "audio": 0, "end": 9646635, "filename": "/hyph_brl_da_dk.dic"}, {"start": 9646635, "audio": 0, "end": 9647199, "filename": "/it.tbl"}, {"start": 9647199, "audio": 0, "end": 9652132, "filename": "/ta-ta-g1.ctb"}, {"start": 9652132, "audio": 0, "end": 9653176, "filename": "/tsn-za-g1.ctb"}, {"start": 9653176, "audio": 0, "end": 9654096, "filename": "/ta.ctb"}], "remote_package_size": 9654096, "package_uuid": "20947335-6d7d-49bc-886e-29452d401f75"}); |
| |
| })(); |
| |
| |
| |
| // 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; |
| |
| if (Module['ENVIRONMENT']) { |
| throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -s ENVIRONMENT=web or -s ENVIRONMENT=node)'); |
| } |
| |
| |
| |
| // `/` 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); |
| |
| // MODULARIZE will export the module in the proper place outside, we don't need to export here |
| |
| process['on']('uncaughtException', function(ex) { |
| // suppress ExitStatus exceptions from showing an error |
| if (!(ex instanceof ExitStatus)) { |
| throw ex; |
| } |
| }); |
| |
| process['on']('unhandledRejection', abort); |
| |
| quit_ = function(status) { |
| process['exit'](status); |
| }; |
| |
| Module['inspect'] = function () { return '[Emscripten Module object]'; }; |
| |
| |
| } else |
| if (ENVIRONMENT_IS_SHELL) { |
| |
| |
| if (typeof read != 'undefined') { |
| read_ = function shell_read(f) { |
| return read(f); |
| }; |
| } |
| |
| readBinary = function readBinary(f) { |
| var data; |
| if (typeof readbuffer === 'function') { |
| return new Uint8Array(readbuffer(f)); |
| } |
| data = read(f, 'binary'); |
| assert(typeof data === 'object'); |
| return data; |
| }; |
| |
| if (typeof scriptArgs != 'undefined') { |
| 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; |
| } |
| // When MODULARIZE (and not _INSTANCE), this JS may be executed later, after document.currentScript |
| // is gone, so we saved it, and we use it here instead of any other info. |
| if (_scriptDir) { |
| scriptDirectory = _scriptDir; |
| } |
| // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. |
| // otherwise, slice off the final part of the url to find the script directory. |
| // if scriptDirectory does not contain a slash, lastIndexOf will return -1, |
| // and scriptDirectory will correctly be replaced with an empty string. |
| if (scriptDirectory.indexOf('blob:') !== 0) { |
| scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/')+1); |
| } else { |
| scriptDirectory = ''; |
| } |
| |
| |
| // Differentiate the Web Worker from the Node Worker case, as reading must |
| // be done differently. |
| { |
| |
| |
| 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 |
| { |
| throw new Error('environment detection error'); |
| } |
| |
| |
| // 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 (!Object.getOwnPropertyDescriptor(Module, 'arguments')) Object.defineProperty(Module, 'arguments', { configurable: true, get: function() { abort('Module.arguments has been replaced with plain arguments_') } }); |
| if (Module['thisProgram']) thisProgram = Module['thisProgram'];if (!Object.getOwnPropertyDescriptor(Module, 'thisProgram')) Object.defineProperty(Module, 'thisProgram', { configurable: true, get: function() { abort('Module.thisProgram has been replaced with plain thisProgram') } }); |
| if (Module['quit']) quit_ = Module['quit'];if (!Object.getOwnPropertyDescriptor(Module, 'quit')) Object.defineProperty(Module, 'quit', { configurable: true, get: function() { abort('Module.quit has been replaced with plain quit_') } }); |
| |
| // perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message |
| // Assertions on removed incoming Module JS APIs. |
| assert(typeof Module['memoryInitializerPrefixURL'] === 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead'); |
| assert(typeof Module['pthreadMainPrefixURL'] === 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead'); |
| assert(typeof Module['cdInitializerPrefixURL'] === 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead'); |
| assert(typeof Module['filePackagePrefixURL'] === 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead'); |
| assert(typeof Module['read'] === 'undefined', 'Module.read option was removed (modify read_ in JS)'); |
| assert(typeof Module['readAsync'] === 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)'); |
| assert(typeof Module['readBinary'] === 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)'); |
| assert(typeof Module['setWindowTitle'] === 'undefined', 'Module.setWindowTitle option was removed (modify setWindowTitle in JS)'); |
| if (!Object.getOwnPropertyDescriptor(Module, 'read')) Object.defineProperty(Module, 'read', { configurable: true, get: function() { abort('Module.read has been replaced with plain read_') } }); |
| if (!Object.getOwnPropertyDescriptor(Module, 'readAsync')) Object.defineProperty(Module, 'readAsync', { configurable: true, get: function() { abort('Module.readAsync has been replaced with plain readAsync') } }); |
| if (!Object.getOwnPropertyDescriptor(Module, 'readBinary')) Object.defineProperty(Module, 'readBinary', { configurable: true, get: function() { abort('Module.readBinary has been replaced with plain readBinary') } }); |
| // TODO: add when SDL2 is fixed if (!Object.getOwnPropertyDescriptor(Module, 'setWindowTitle')) Object.defineProperty(Module, 'setWindowTitle', { configurable: true, get: function() { abort('Module.setWindowTitle has been replaced with plain setWindowTitle') } }); |
| var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js'; |
| var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js'; |
| var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js'; |
| var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js'; |
| |
| |
| // 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; |
| |
| // stack management, and other functionality that is provided by the compiled code, |
| // should not be used before it is ready |
| stackSave = stackRestore = stackAlloc = function() { |
| abort('cannot use the stack before compiled code is ready to run, and has provided stack access'); |
| }; |
| |
| function staticAlloc(size) { |
| abort('staticAlloc is no longer available at runtime; instead, perform static allocations at compile time (using makeStaticAlloc)'); |
| } |
| |
| function dynamicAlloc(size) { |
| assert(DYNAMICTOP_PTR); |
| var ret = HEAP32[DYNAMICTOP_PTR>>2]; |
| var end = (ret + size + 15) & -16; |
| if (end > _emscripten_get_heap_size()) { |
| abort('failure to dynamicAlloc - memory growth etc. is not supported there, call malloc/sbrk directly'); |
| } |
| HEAP32[DYNAMICTOP_PTR>>2] = end; |
| return ret; |
| } |
| |
| function alignMemory(size, factor) { |
| if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default |
| return Math.ceil(size / factor) * factor; |
| } |
| |
| function getNativeTypeSize(type) { |
| switch (type) { |
| case 'i1': case 'i8': return 1; |
| case 'i16': return 2; |
| case 'i32': return 4; |
| case 'i64': return 8; |
| case 'float': return 4; |
| case 'double': return 8; |
| default: { |
| if (type[type.length-1] === '*') { |
| return 4; // A pointer |
| } else if (type[0] === 'i') { |
| var bits = parseInt(type.substr(1)); |
| assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type); |
| return bits / 8; |
| } else { |
| return 0; |
| } |
| } |
| } |
| } |
| |
| function warnOnce(text) { |
| if (!warnOnce.shown) warnOnce.shown = {}; |
| if (!warnOnce.shown[text]) { |
| warnOnce.shown[text] = 1; |
| err(text); |
| } |
| } |
| |
| var asm2wasmImports = { // special asm2wasm imports |
| "f64-rem": function(x, y) { |
| return x % y; |
| }, |
| "debugger": function() { |
| debugger; |
| } |
| }; |
| |
| |
| |
| var jsCallStartIndex = 1; |
| var functionPointers = new Array(1); |
| |
| // 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) { |
| assert(typeof func !== 'undefined'); |
| |
| |
| var base = 0; |
| for (var i = base; i < base + 1; i++) { |
| if (!functionPointers[i]) { |
| functionPointers[i] = func; |
| return jsCallStartIndex + i; |
| } |
| } |
| throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.'; |
| |
| } |
| |
| function removeFunction(index) { |
| |
| functionPointers[index-jsCallStartIndex] = null; |
| } |
| |
| var funcWrappers = {}; |
| |
| function getFuncWrapper(func, sig) { |
| if (!func) return; // on null pointer, return undefined |
| assert(sig); |
| if (!funcWrappers[sig]) { |
| funcWrappers[sig] = {}; |
| } |
| var sigCache = funcWrappers[sig]; |
| if (!sigCache[func]) { |
| // optimize away arguments usage in common cases |
| if (sig.length === 1) { |
| sigCache[func] = function dynCall_wrapper() { |
| return dynCall(sig, func); |
| }; |
| } else if (sig.length === 2) { |
| sigCache[func] = function dynCall_wrapper(arg) { |
| return dynCall(sig, func, [arg]); |
| }; |
| } else { |
| // general case |
| sigCache[func] = function dynCall_wrapper() { |
| return dynCall(sig, func, Array.prototype.slice.call(arguments)); |
| }; |
| } |
| } |
| return sigCache[func]; |
| } |
| |
| |
| function makeBigInt(low, high, unsigned) { |
| return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0)); |
| } |
| |
| function dynCall(sig, ptr, args) { |
| if (args && args.length) { |
| assert(args.length == sig.length-1); |
| assert(('dynCall_' + sig) in Module, 'bad function pointer type - no table for sig \'' + sig + '\''); |
| return Module['dynCall_' + sig].apply(null, [ptr].concat(args)); |
| } else { |
| assert(sig.length == 1); |
| assert(('dynCall_' + sig) in Module, 'bad function pointer type - no table for sig \'' + sig + '\''); |
| return Module['dynCall_' + sig].call(null, ptr); |
| } |
| } |
| |
| var tempRet0 = 0; |
| |
| var setTempRet0 = function(value) { |
| tempRet0 = value; |
| }; |
| |
| var getTempRet0 = function() { |
| return tempRet0; |
| }; |
| |
| function getCompilerSetting(name) { |
| throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for getCompilerSetting or emscripten_get_compiler_setting to work'; |
| } |
| |
| var Runtime = { |
| // helpful errors |
| getTempRet0: function() { abort('getTempRet0() is now a top-level function, after removing the Runtime object. Remove "Runtime."') }, |
| staticAlloc: function() { abort('staticAlloc() is now a top-level function, after removing the Runtime object. Remove "Runtime."') }, |
| stackAlloc: function() { abort('stackAlloc() is now a top-level function, after removing the Runtime object. Remove "Runtime."') }, |
| }; |
| |
| // The address globals begin at. Very low in memory, for code size and optimization opportunities. |
| // Above 0 is static memory, starting with globals. |
| // Then the stack. |
| // Then 'dynamic' memory for sbrk. |
| var GLOBAL_BASE = 1024; |
| |
| |
| |
| |
| // === Preamble library stuff === |
| |
| // Documentation for the public APIs defined in this file must be updated in: |
| // site/source/docs/api_reference/preamble.js.rst |
| // A prebuilt local version of the documentation is available at: |
| // site/build/text/docs/api_reference/preamble.js.txt |
| // You can also build docs locally as HTML or other formats in site/ |
| // An online HTML version (which may be of a different version of Emscripten) |
| // is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html |
| |
| |
| var wasmBinary;if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];if (!Object.getOwnPropertyDescriptor(Module, 'wasmBinary')) Object.defineProperty(Module, 'wasmBinary', { configurable: true, get: function() { abort('Module.wasmBinary has been replaced with plain wasmBinary') } }); |
| var noExitRuntime;if (Module['noExitRuntime']) noExitRuntime = Module['noExitRuntime'];if (!Object.getOwnPropertyDescriptor(Module, 'noExitRuntime')) Object.defineProperty(Module, 'noExitRuntime', { configurable: true, get: function() { abort('Module.noExitRuntime has been replaced with plain noExitRuntime') } }); |
| |
| |
| if (typeof WebAssembly !== 'object') { |
| abort('No WebAssembly support found. Build with -s WASM=0 to target JavaScript instead.'); |
| } |
| |
| |
| // 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': 92, |
| 'maximum': 92, |
| 'element': 'anyfunc' |
| }); |
| |
| |
| //======================================== |
| // 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; |
| assert(returnType !== 'array', 'Return type should not be "array".'); |
| if (args) { |
| for (var i = 0; i < args.length; i++) { |
| var converter = toC[argTypes[i]]; |
| if (converter) { |
| if (stack === 0) stack = 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) { |
| 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; |
| } |
| assert(type, 'Must know what type to store in allocate!'); |
| |
| if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later |
| |
| setValue(ret+i, curr, type); |
| |
| // no need to look up size unless type changes, so cache it |
| if (previousType !== type) { |
| typeSize = getNativeTypeSize(type); |
| previousType = type; |
| } |
| i += typeSize; |
| } |
| |
| return ret; |
| } |
| |
| // Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready |
| function getMemory(size) { |
| if (!runtimeInitialized) return dynamicAlloc(size); |
| return _malloc(size); |
| } |
| |
| |
| |
| |
| /** @type {function(number, number=)} */ |
| function Pointer_stringify(ptr, length) { |
| abort("this function has been removed - you should use UTF8ToString(ptr, maxBytesToRead) instead!"); |
| } |
| |
| // Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns |
| // a copy of that string as a Javascript String object. |
| |
| function AsciiToString(ptr) { |
| var str = ''; |
| while (1) { |
| var ch = HEAPU8[((ptr++)>>0)]; |
| if (!ch) return str; |
| str += String.fromCharCode(ch); |
| } |
| } |
| |
| // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', |
| // null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP. |
| |
| function stringToAscii(str, outPtr) { |
| return writeAsciiToMemory(str, outPtr, false); |
| } |
| |
| |
| // Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns |
| // a copy of that string as a Javascript String object. |
| |
| var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined; |
| |
| /** |
| * @param {number} idx |
| * @param {number=} maxBytesToRead |
| * @return {string} |
| */ |
| function UTF8ArrayToString(u8Array, idx, maxBytesToRead) { |
| var endIdx = idx + maxBytesToRead; |
| var endPtr = idx; |
| // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. |
| // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. |
| // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity) |
| while (u8Array[endPtr] && !(endPtr >= endIdx)) ++endPtr; |
| |
| if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) { |
| return UTF8Decoder.decode(u8Array.subarray(idx, endPtr)); |
| } else { |
| var str = ''; |
| // If building with TextDecoder, we have already computed the string length above, so test loop end condition against that |
| while (idx < endPtr) { |
| // For UTF8 byte structure, see: |
| // http://en.wikipedia.org/wiki/UTF-8#Description |
| // https://www.ietf.org/rfc/rfc2279.txt |
| // https://tools.ietf.org/html/rfc3629 |
| var u0 = u8Array[idx++]; |
| if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } |
| var u1 = u8Array[idx++] & 63; |
| if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } |
| var u2 = u8Array[idx++] & 63; |
| if ((u0 & 0xF0) == 0xE0) { |
| u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; |
| } else { |
| if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte 0x' + u0.toString(16) + ' encountered when deserializing a UTF-8 string on the asm.js/wasm heap to a JS string!'); |
| 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; |
| if (u >= 0x200000) warnOnce('Invalid Unicode code point 0x' + u.toString(16) + ' encountered when serializing a JS string to an UTF-8 string on the asm.js/wasm heap! (Valid unicode code points should be in range 0-0x1FFFFF).'); |
| 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) { |
| assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); |
| return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite); |
| } |
| |
| // Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte. |
| function lengthBytesUTF8(str) { |
| var len = 0; |
| for (var i = 0; i < str.length; ++i) { |
| // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. |
| // See http://unicode.org/faq/utf_bom.html#utf16-3 |
| var u = str.charCodeAt(i); // possibly a lead surrogate |
| if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF); |
| if (u <= 0x7F) ++len; |
| else if (u <= 0x7FF) len += 2; |
| else if (u <= 0xFFFF) len += 3; |
| else len += 4; |
| } |
| return len; |
| } |
| |
| |
| // Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns |
| // a copy of that string as a Javascript String object. |
| |
| var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined; |
| function UTF16ToString(ptr) { |
| assert(ptr % 2 == 0, 'Pointer passed to UTF16ToString must be aligned to two bytes!'); |
| var endPtr = ptr; |
| // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. |
| // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. |
| var idx = endPtr >> 1; |
| while (HEAP16[idx]) ++idx; |
| endPtr = idx << 1; |
| |
| if (endPtr - ptr > 32 && UTF16Decoder) { |
| return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); |
| } else { |
| var i = 0; |
| |
| var str = ''; |
| while (1) { |
| var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; |
| if (codeUnit == 0) return str; |
| ++i; |
| // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through. |
| str += String.fromCharCode(codeUnit); |
| } |
| } |
| } |
| |
| // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', |
| // null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP. |
| // Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write. |
| // Parameters: |
| // str: the Javascript string to copy. |
| // outPtr: Byte address in Emscripten HEAP where to write the string to. |
| // maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null |
| // terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else. |
| // maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator. |
| // Returns the number of bytes written, EXCLUDING the null terminator. |
| |
| function stringToUTF16(str, outPtr, maxBytesToWrite) { |
| assert(outPtr % 2 == 0, 'Pointer passed to stringToUTF16 must be aligned to two bytes!'); |
| assert(typeof maxBytesToWrite == 'number', 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); |
| // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. |
| if (maxBytesToWrite === undefined) { |
| maxBytesToWrite = 0x7FFFFFFF; |
| } |
| if (maxBytesToWrite < 2) return 0; |
| maxBytesToWrite -= 2; // Null terminator. |
| var startPtr = outPtr; |
| var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; |
| for (var i = 0; i < numCharsToWrite; ++i) { |
| // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. |
| var codeUnit = str.charCodeAt(i); // possibly a lead surrogate |
| HEAP16[((outPtr)>>1)]=codeUnit; |
| outPtr += 2; |
| } |
| // Null-terminate the pointer to the HEAP. |
| HEAP16[((outPtr)>>1)]=0; |
| return outPtr - startPtr; |
| } |
| |
| // Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. |
| |
| function lengthBytesUTF16(str) { |
| return str.length*2; |
| } |
| |
| function UTF32ToString(ptr) { |
| assert(ptr % 4 == 0, 'Pointer passed to UTF32ToString must be aligned to four bytes!'); |
| var i = 0; |
| |
| var str = ''; |
| while (1) { |
| var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; |
| if (utf32 == 0) |
| return str; |
| ++i; |
| // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. |
| // See http://unicode.org/faq/utf_bom.html#utf16-3 |
| if (utf32 >= 0x10000) { |
| var ch = utf32 - 0x10000; |
| str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); |
| } else { |
| str += String.fromCharCode(utf32); |
| } |
| } |
| } |
| |
| // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', |
| // null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP. |
| // Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write. |
| // Parameters: |
| // str: the Javascript string to copy. |
| // outPtr: Byte address in Emscripten HEAP where to write the string to. |
| // maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null |
| // terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else. |
| // maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator. |
| // Returns the number of bytes written, EXCLUDING the null terminator. |
| |
| function stringToUTF32(str, outPtr, maxBytesToWrite) { |
| assert(outPtr % 4 == 0, 'Pointer passed to stringToUTF32 must be aligned to four bytes!'); |
| assert(typeof maxBytesToWrite == 'number', 'stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); |
| // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. |
| if (maxBytesToWrite === undefined) { |
| maxBytesToWrite = 0x7FFFFFFF; |
| } |
| if (maxBytesToWrite < 4) return 0; |
| var startPtr = outPtr; |
| var endPtr = startPtr + maxBytesToWrite - 4; |
| for (var i = 0; i < str.length; ++i) { |
| // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. |
| // See http://unicode.org/faq/utf_bom.html#utf16-3 |
| var codeUnit = str.charCodeAt(i); // possibly a lead surrogate |
| if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { |
| var trailSurrogate = str.charCodeAt(++i); |
| codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); |
| } |
| HEAP32[((outPtr)>>2)]=codeUnit; |
| outPtr += 4; |
| if (outPtr + 4 > endPtr) break; |
| } |
| // Null-terminate the pointer to the HEAP. |
| HEAP32[((outPtr)>>2)]=0; |
| return outPtr - startPtr; |
| } |
| |
| // Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. |
| |
| function lengthBytesUTF32(str) { |
| var len = 0; |
| for (var i = 0; i < str.length; ++i) { |
| // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. |
| // See http://unicode.org/faq/utf_bom.html#utf16-3 |
| var codeUnit = str.charCodeAt(i); |
| if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. |
| len += 4; |
| } |
| |
| return len; |
| } |
| |
| // 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) { |
| assert(array.length >= 0, 'writeArrayToMemory array must have a length (should be an array or typed array)') |
| HEAP8.set(array, buffer); |
| } |
| |
| function writeAsciiToMemory(str, buffer, dontAddNull) { |
| for (var i = 0; i < str.length; ++i) { |
| assert(str.charCodeAt(i) === str.charCodeAt(i)&0xff); |
| HEAP8[((buffer++)>>0)]=str.charCodeAt(i); |
| } |
| // Null-terminate the pointer to the HEAP. |
| if (!dontAddNull) HEAP8[((buffer)>>0)]=0; |
| } |
| |
| |
| |
| |
| // 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 = 40176, |
| STACKTOP = STACK_BASE, |
| STACK_MAX = 5283056, |
| DYNAMIC_BASE = 5283056, |
| DYNAMICTOP_PTR = 39984; |
| |
| assert(STACK_BASE % 16 === 0, 'stack must start aligned'); |
| assert(DYNAMIC_BASE % 16 === 0, 'heap must start aligned'); |
| |
| |
| |
| var TOTAL_STACK = 5242880; |
| if (Module['TOTAL_STACK']) assert(TOTAL_STACK === Module['TOTAL_STACK'], 'the stack size can no longer be determined at runtime') |
| |
| var INITIAL_TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 167772160;if (!Object.getOwnPropertyDescriptor(Module, 'TOTAL_MEMORY')) Object.defineProperty(Module, 'TOTAL_MEMORY', { configurable: true, get: function() { abort('Module.TOTAL_MEMORY has been replaced with plain INITIAL_TOTAL_MEMORY') } }); |
| |
| assert(INITIAL_TOTAL_MEMORY >= TOTAL_STACK, 'TOTAL_MEMORY should be larger than TOTAL_STACK, was ' + INITIAL_TOTAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')'); |
| |
| // check for full engine support (use string 'subarray' to avoid closure compiler confusion) |
| assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray !== undefined && Int32Array.prototype.set !== undefined, |
| 'JS engine does not provide full typed array support'); |
| |
| |
| |
| |
| |
| |
| // 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 (Module['wasmMemory']) { |
| wasmMemory = Module['wasmMemory']; |
| } else |
| { |
| wasmMemory = new WebAssembly.Memory({ |
| 'initial': INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE |
| , |
| 'maximum': INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE |
| }); |
| } |
| |
| |
| if (wasmMemory) { |
| buffer = wasmMemory.buffer; |
| } |
| |
| // If the user provides an incorrect length, just use that length instead rather than providing the user to |
| // specifically provide the memory length with Module['TOTAL_MEMORY']. |
| INITIAL_TOTAL_MEMORY = buffer.byteLength; |
| assert(INITIAL_TOTAL_MEMORY % WASM_PAGE_SIZE === 0); |
| updateGlobalBufferAndViews(buffer); |
| |
| HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE; |
| |
| |
| |
| |
| // Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode. |
| function writeStackCookie() { |
| assert((STACK_MAX & 3) == 0); |
| HEAPU32[(STACK_MAX >> 2)-1] = 0x02135467; |
| HEAPU32[(STACK_MAX >> 2)-2] = 0x89BACDFE; |
| // Also test the global address 0 for integrity. |
| // We don't do this with ASan because ASan does its own checks for this. |
| HEAP32[0] = 0x63736d65; /* 'emsc' */ |
| } |
| |
| function checkStackCookie() { |
| var cookie1 = HEAPU32[(STACK_MAX >> 2)-1]; |
| var cookie2 = HEAPU32[(STACK_MAX >> 2)-2]; |
| if (cookie1 != 0x02135467 || cookie2 != 0x89BACDFE) { |
| abort('Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x02135467, but received 0x' + cookie2.toString(16) + ' ' + cookie1.toString(16)); |
| } |
| // Also test the global address 0 for integrity. |
| // We don't do this with ASan because ASan does its own checks for this. |
| if (HEAP32[0] !== 0x63736d65 /* 'emsc' */) abort('Runtime error: The application has corrupted its heap memory area (address zero)!'); |
| } |
| |
| function abortStackOverflow(allocSize) { |
| abort('Stack overflow! Attempted to allocate ' + allocSize + ' bytes on the stack, but stack has only ' + (STACK_MAX - stackSave() + allocSize) + ' bytes available!'); |
| } |
| |
| |
| |
| |
| // Endianness check (note: assumes compiler arch was little-endian) |
| (function() { |
| var h16 = new Int16Array(1); |
| var h8 = new Int8Array(h16.buffer); |
| h16[0] = 0x6373; |
| if (h8[0] !== 0x73 || h8[1] !== 0x63) throw 'Runtime error: expected the system to be little-endian!'; |
| })(); |
| |
| function abortFnPtrError(ptr, sig) { |
| abort("Invalid function pointer " + ptr + " called with signature '" + sig + "'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this). Build with ASSERTIONS=2 for more info."); |
| } |
| |
| |
| |
| function callRuntimeCallbacks(callbacks) { |
| while(callbacks.length > 0) { |
| var callback = callbacks.shift(); |
| if (typeof callback == 'function') { |
| callback(); |
| continue; |
| } |
| var func = callback.func; |
| if (typeof func === 'number') { |
| if (callback.arg === undefined) { |
| Module['dynCall_v'](func); |
| } else { |
| Module['dynCall_vi'](func, callback.arg); |
| } |
| } else { |
| func(callback.arg === undefined ? null : callback.arg); |
| } |
| } |
| } |
| |
| var __ATPRERUN__ = []; // functions called before the runtime is initialized |
| var __ATINIT__ = []; // functions called during startup |
| var __ATMAIN__ = []; // functions called when main() is to be run |
| var __ATEXIT__ = []; // functions called during shutdown |
| var __ATPOSTRUN__ = []; // functions called after the main() is called |
| |
| var runtimeInitialized = false; |
| var runtimeExited = false; |
| |
| |
| function preRun() { |
| |
| if (Module['preRun']) { |
| if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; |
| while (Module['preRun'].length) { |
| addOnPreRun(Module['preRun'].shift()); |
| } |
| } |
| |
| callRuntimeCallbacks(__ATPRERUN__); |
| } |
| |
| function initRuntime() { |
| checkStackCookie(); |
| assert(!runtimeInitialized); |
| runtimeInitialized = true; |
| if (!Module["noFSInit"] && !FS.init.initialized) FS.init(); |
| TTY.init(); |
| callRuntimeCallbacks(__ATINIT__); |
| } |
| |
| function preMain() { |
| checkStackCookie(); |
| FS.ignorePermissions = false; |
| callRuntimeCallbacks(__ATMAIN__); |
| } |
| |
| function exitRuntime() { |
| checkStackCookie(); |
| runtimeExited = true; |
| } |
| |
| function postRun() { |
| checkStackCookie(); |
| |
| 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; |
| } |
| |
| |
| assert(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); |
| assert(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); |
| assert(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); |
| assert(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); |
| |
| 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 |
| var runDependencyTracking = {}; |
| |
| function getUniqueRunDependency(id) { |
| var orig = id; |
| while (1) { |
| if (!runDependencyTracking[id]) return id; |
| id = orig + Math.random(); |
| } |
| return id; |
| } |
| |
| function addRunDependency(id) { |
| runDependencies++; |
| |
| if (Module['monitorRunDependencies']) { |
| Module['monitorRunDependencies'](runDependencies); |
| } |
| |
| if (id) { |
| assert(!runDependencyTracking[id]); |
| runDependencyTracking[id] = 1; |
| if (runDependencyWatcher === null && typeof setInterval !== 'undefined') { |
| // Check for missing dependencies every few seconds |
| runDependencyWatcher = setInterval(function() { |
| if (ABORT) { |
| clearInterval(runDependencyWatcher); |
| runDependencyWatcher = null; |
| return; |
| } |
| var shown = false; |
| for (var dep in runDependencyTracking) { |
| if (!shown) { |
| shown = true; |
| err('still waiting on run dependencies:'); |
| } |
| err('dependency: ' + dep); |
| } |
| if (shown) { |
| err('(end of list)'); |
| } |
| }, 10000); |
| } |
| } else { |
| err('warning: run dependency added without ID'); |
| } |
| } |
| |
| function removeRunDependency(id) { |
| runDependencies--; |
| |
| if (Module['monitorRunDependencies']) { |
| Module['monitorRunDependencies'](runDependencies); |
| } |
| |
| if (id) { |
| assert(runDependencyTracking[id]); |
| delete runDependencyTracking[id]; |
| } else { |
| err('warning: run dependency removed without ID'); |
| } |
| if (runDependencies == 0) { |
| if (runDependencyWatcher !== null) { |
| clearInterval(runDependencyWatcher); |
| runDependencyWatcher = null; |
| } |
| if (dependenciesFulfilled) { |
| var callback = dependenciesFulfilled; |
| dependenciesFulfilled = null; |
| callback(); // can add another dependenciesFulfilled |
| } |
| } |
| } |
| |
| Module["preloadedImages"] = {}; // maps url to image data |
| Module["preloadedAudios"] = {}; // maps url to audio data |
| |
| |
| function abort(what) { |
| if (Module['onAbort']) { |
| Module['onAbort'](what); |
| } |
| |
| what += ''; |
| out(what); |
| err(what); |
| |
| ABORT = true; |
| EXITSTATUS = 1; |
| |
| var output = 'abort(' + what + ') at ' + stackTrace(); |
| what = output; |
| |
| // 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 = 'liblouis_wasm.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 |
| , |
| 'global': { |
| 'NaN': NaN, |
| 'Infinity': Infinity |
| }, |
| 'global.Math': Math, |
| 'asm2wasm': asm2wasmImports |
| }; |
| // Load the wasm module and create an instance of using native support in the JS engine. |
| // handle a generated wasm instance, receiving its exports and |
| // performing other necessary setup |
| function receiveInstance(instance, module) { |
| var exports = instance.exports; |
| Module['asm'] = exports; |
| removeRunDependency('wasm-instantiate'); |
| } |
| // we can't run yet (except in a pthread, where we have a custom sync instantiator) |
| addRunDependency('wasm-instantiate'); |
| |
| |
| // Async compilation can be confusing when an error on the page overwrites Module |
| // (for example, if the order of elements is wrong, and the one defining Module is |
| // later), so we save Module and check it later. |
| var trueModule = Module; |
| 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 |
| assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?'); |
| trueModule = null; |
| // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. |
| // When the regression is fixed, can restore the above USE_PTHREADS-enabled path. |
| receiveInstance(output['instance']); |
| } |
| |
| |
| function instantiateArrayBuffer(receiver) { |
| return getBinaryPromise().then(function(binary) { |
| return WebAssembly.instantiate(binary, info); |
| }).then(receiver, function(reason) { |
| err('failed to asynchronously prepare wasm: ' + reason); |
| abort(reason); |
| }); |
| } |
| |
| // Prefer streaming instantiation if available. |
| function instantiateAsync() { |
| if (!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 |
| } |
| |
| Module['asm'] = createWasm; |
| |
| // Globals used by JS i64 conversions |
| var tempDouble; |
| var tempI64; |
| |
| // === Body === |
| |
| var ASM_CONSTS = []; |
| |
| |
| |
| |
| |
| // STATICTOP = STATIC_BASE + 39152; |
| /* global initializers */ __ATINIT__.push({ func: function() { ___emscripten_environ_constructor() } }); |
| |
| |
| |
| |
| |
| |
| |
| |
| /* no memory initializer */ |
| var tempDoublePtr = 40160 |
| assert(tempDoublePtr % 8 == 0); |
| |
| function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much |
| HEAP8[tempDoublePtr] = HEAP8[ptr]; |
| HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; |
| HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; |
| HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; |
| } |
| |
| function copyTempDouble(ptr) { |
| HEAP8[tempDoublePtr] = HEAP8[ptr]; |
| HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; |
| HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; |
| HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; |
| HEAP8[tempDoublePtr+4] = HEAP8[ptr+4]; |
| HEAP8[tempDoublePtr+5] = HEAP8[ptr+5]; |
| HEAP8[tempDoublePtr+6] = HEAP8[ptr+6]; |
| HEAP8[tempDoublePtr+7] = HEAP8[ptr+7]; |
| } |
| |
| // {{PRE_LIBRARY}} |
| |
| |
| function demangle(func) { |
| warnOnce('warning: build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling'); |
| return func; |
| } |
| |
| 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 + ']'); |
| }); |
| } |
| |
| function jsStackTrace() { |
| var err = new Error(); |
| if (!err.stack) { |
| // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown, |
| // so try that as a special-case. |
| try { |
| throw new Error(0); |
| } catch(e) { |
| err = e; |
| } |
| if (!err.stack) { |
| return '(no stack trace available)'; |
| } |
| } |
| return err.stack.toString(); |
| } |
| |
| function stackTrace() { |
| var js = jsStackTrace(); |
| if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace'](); |
| return demangleAll(js); |
| } |
| |
| |
| var ENV={};function ___buildEnvironment(environ) { |
| // WARNING: Arbitrary limit! |
| var MAX_ENV_VALUES = 64; |
| var TOTAL_ENV_SIZE = 1024; |
| |
| // Statically allocate memory for the environment. |
| var poolPtr; |
| var envPtr; |
| if (!___buildEnvironment.called) { |
| ___buildEnvironment.called = true; |
| // Set default values. Use string keys for Closure Compiler compatibility. |
| ENV['USER'] = 'web_user'; |
| ENV['LOGNAME'] = 'web_user'; |
| ENV['PATH'] = '/'; |
| ENV['PWD'] = '/'; |
| ENV['HOME'] = '/home/web_user'; |
| // Browser language detection #8751 |
| ENV['LANG'] = ((typeof navigator === 'object' && navigator.languages && navigator.languages[0]) || 'C').replace('-', '_') + '.UTF-8'; |
| ENV['_'] = thisProgram; |
| // Allocate memory. |
| poolPtr = getMemory(TOTAL_ENV_SIZE); |
| envPtr = getMemory(MAX_ENV_VALUES * 4); |
| HEAP32[((envPtr)>>2)]=poolPtr; |
| HEAP32[((environ)>>2)]=envPtr; |
| } else { |
| envPtr = HEAP32[((environ)>>2)]; |
| poolPtr = HEAP32[((envPtr)>>2)]; |
| } |
| |
| // Collect key=value lines. |
| var strings = []; |
| var totalSize = 0; |
| for (var key in ENV) { |
| if (typeof ENV[key] === 'string') { |
| var line = key + '=' + ENV[key]; |
| strings.push(line); |
| totalSize += line.length; |
| } |
| } |
| if (totalSize > TOTAL_ENV_SIZE) { |
| throw new Error('Environment size exceeded TOTAL_ENV_SIZE!'); |
| } |
| |
| // Make new. |
| var ptrSize = 4; |
| for (var i = 0; i < strings.length; i++) { |
| var line = strings[i]; |
| writeAsciiToMemory(line, poolPtr); |
| HEAP32[(((envPtr)+(i * ptrSize))>>2)]=poolPtr; |
| poolPtr += line.length + 1; |
| } |
| HEAP32[(((envPtr)+(strings.length * ptrSize))>>2)]=0; |
| } |
| |
| function ___lock() {} |
| |
| |
| |
| 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); |
| }}; |
| |
| |
| function ___setErrNo(value) { |
| if (Module['___errno_location']) HEAP32[((Module['___errno_location']())>>2)]=value; |
| else err('failed to set errno from JS'); |
| return value; |
| } |
| |
| 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('/'); |
| }}; |
| |
| 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 = []; |
| } |
| }}}; |
| |
| 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); |
| assert(size >= 0); |
| 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) { |
| // The data buffer should be a typed array view |
| assert(!(buffer instanceof ArrayBuffer)); |
| |
| 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) { |
| assert(position === 0, 'canOwn must imply no weird position inside the file'); |
| 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) { |
| // The data buffer should be a typed array view |
| assert(!(buffer instanceof ArrayBuffer)); |
| 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; |
| }}}; |
| |
| var ERRNO_MESSAGES={0:"Success",1:"Arg list too long",2:"Permission denied",3:"Address already in use",4:"Address not available",5:"Address family not supported by protocol family",6:"No more processes",7:"Socket already connected",8:"Bad file number",9:"Trying to read unreadable message",10:"Mount device busy",11:"Operation canceled",12:"No children",13:"Connection aborted",14:"Connection refused",15:"Connection reset by peer",16:"File locking deadlock error",17:"Destination address required",18:"Math arg out of domain of func",19:"Quota exceeded",20:"File exists",21:"Bad address",22:"File too large",23:"Host is unreachable",24:"Identifier removed",25:"Illegal byte sequence",26:"Connection already in progress",27:"Interrupted system call",28:"Invalid argument",29:"I/O error",30:"Socket is already connected",31:"Is a directory",32:"Too many symbolic links",33:"Too many open files",34:"Too many links",35:"Message too long",36:"Multihop attempted",37:"File or path name too long",38:"Network interface is not configured",39:"Connection reset by network",40:"Network is unreachable",41:"Too many open files in system",42:"No buffer space available",43:"No such device",44:"No such file or directory",45:"Exec format error",46:"No record locks available",47:"The link has been severed",48:"Not enough core",49:"No message of desired type",50:"Protocol not available",51:"No space left on device",52:"Function not implemented",53:"Socket is not connected",54:"Not a directory",55:"Directory not empty",56:"State not recoverable",57:"Socket operation on non-socket",59:"Not a typewriter",60:"No such device or address",61:"Value too large for defined data type",62:"Previous owner died",63:"Not super-user",64:"Broken pipe",65:"Protocol error",66:"Unknown protocol",67:"Protocol wrong type for socket",68:"Math result not representable",69:"Read only file system",70:"Illegal seek",71:"No such process",72:"Stale file handle",73:"Connection timed out",74:"Text file busy",75:"Cross-device link",100:"Device not a stream",101:"Bad font file fmt",102:"Invalid slot",103:"Invalid request code",104:"No anode",105:"Block device required",106:"Channel number out of range",107:"Level 3 halted",108:"Level 3 reset",109:"Link number out of range",110:"Protocol driver not attached",111:"No CSI structure available",112:"Level 2 halted",113:"Invalid exchange",114:"Invalid request descriptor",115:"Exchange full",116:"No data (for no delay io)",117:"Timer expired",118:"Out of streams resources",119:"Machine is not on the network",120:"Package not installed",121:"The object is remote",122:"Advertise error",123:"Srmount error",124:"Communication error on send",125:"Cross mount point (not really error)",126:"Given log. name not unique",127:"f.d. invalid for this operation",128:"Remote address changed",129:"Can access a needed shared lib",130:"Accessing a corrupted shared lib",131:".lib section in a.out corrupted",132:"Attempting to link in too many libs",133:"Attempting to exec a shared library",135:"Streams pipe error",136:"Too many users",137:"Socket type not supported",138:"Not supported",139:"Protocol family not supported",140:"Can't send after socket shutdown",141:"Too many references",142:"Host is down",148:"No medium (in tape drive)",156:"Level 2 not synchronized"}; |
| |
| 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};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) { |
| assert(FS.syncFSRequests > 0); |
| 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) { |
| if (typeof type === 'string') { |
| // The filesystem was not included, and instead we have an error |
| // message stored in the variable. |
| throw type; |
| } |
| 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); |
| assert(idx !== -1); |
| 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("no cryptographic support found for random_device. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: function(array) { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };"); }; |
| } |
| 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'); |
| assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')'); |
| assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')'); |
| assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')'); |
| },ensureErrnoError:function() { |
| if (FS.ErrnoError) return; |
| FS.ErrnoError = function ErrnoError(errno, node) { |
| this.node = node; |
| this.setErrno = function(errno) { |
| this.errno = errno; |
| for (var key in ERRNO_CODES) { |
| if (ERRNO_CODES[key] === errno) { |
| this.code = key; |
| break; |
| } |
| } |
| }; |
| this.setErrno(errno); |
| this.message = ERRNO_MESSAGES[errno]; |
| |
| // Try to get a maximally helpful stack trace. On Node.js, getting Error.stack |
| // now ensures it shows what we want. |
| if (this.stack) { |
| // Define the stack property for Node.js 4, which otherwise errors on the next line. |
| Object.defineProperty(this, "stack", { value: (new Error).stack, writable: true }); |
| this.stack = demangleAll(this.stack); |
| } |
| }; |
| 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, |
| }; |
| },init:function(input, output, error) { |
| assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)'); |
| 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); |
| assert(size >= 0); |
| 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; |
| }};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(); |
| if (low >= 0) assert(high === 0); |
| else assert(high === -1); |
| return low; |
| },getZero:function() { |
| assert(SYSCALLS.get() === 0); |
| }};function ___syscall195(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; |
| } |
| } |
| |
| function ___syscall220(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; |
| } |
| } |
| |
| function ___syscall221(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; |
| } |
| } |
| |
| function ___syscall5(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; |
| } |
| } |
| |
| function ___syscall54(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; |
| } |
| } |
| |
| function ___unlock() {} |
| |
| |
| function _fd_close(fd) {try { |
| |
| var stream = SYSCALLS.getStreamFromFD(fd); |
| FS.close(stream); |
| return 0; |
| } catch (e) { |
| if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); |
| return e.errno; |
| } |
| }function ___wasi_fd_close( |
| ) { |
| return _fd_close.apply(null, arguments) |
| } |
| |
| |
| function _fd_read(fd, iov, iovcnt, pnum) {try { |
| |
| var stream = SYSCALLS.getStreamFromFD(fd); |
| var num = SYSCALLS.doReadv(stream, iov, iovcnt); |
| HEAP32[((pnum)>>2)]=num |
| return 0; |
| } catch (e) { |
| if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); |
| return e.errno; |
| } |
| }function ___wasi_fd_read( |
| ) { |
| return _fd_read.apply(null, arguments) |
| } |
| |
| |
| function _fd_seek(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; |
| } |
| }function ___wasi_fd_seek( |
| ) { |
| return _fd_seek.apply(null, arguments) |
| } |
| |
| |
| function _fd_write(fd, iov, iovcnt, pnum) {try { |
| |
| var stream = SYSCALLS.getStreamFromFD(fd); |
| var num = SYSCALLS.doWritev(stream, iov, iovcnt); |
| HEAP32[((pnum)>>2)]=num |
| return 0; |
| } catch (e) { |
| if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); |
| return e.errno; |
| } |
| }function ___wasi_fd_write( |
| ) { |
| return _fd_write.apply(null, arguments) |
| } |
| |
| function _emscripten_get_heap_size() { |
| return HEAP8.length; |
| } |
| |
| |
| |
| |
| function abortOnCannotGrowMemory(requestedSize) { |
| abort('Cannot enlarge memory arrays to size ' + requestedSize + ' bytes (OOM). Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + HEAP8.length + ', (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 '); |
| }function _emscripten_resize_heap(requestedSize) { |
| abortOnCannotGrowMemory(requestedSize); |
| } |
| |
| function _exit(status) { |
| // void _exit(int status); |
| // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html |
| exit(status); |
| } |
| |
| function _getenv(name) { |
| // char *getenv(const char *name); |
| // http://pubs.opengroup.org/onlinepubs/009695399/functions/getenv.html |
| if (name === 0) return 0; |
| name = UTF8ToString(name); |
| if (!ENV.hasOwnProperty(name)) return 0; |
| |
| if (_getenv.ret) _free(_getenv.ret); |
| _getenv.ret = allocateUTF8(ENV[name]); |
| return _getenv.ret; |
| } |
| |
| function _llvm_stackrestore(p) { |
| var self = _llvm_stacksave; |
| var ret = self.LLVM_SAVEDSTACKS[p]; |
| self.LLVM_SAVEDSTACKS.splice(p, 1); |
| stackRestore(ret); |
| } |
| |
| function _llvm_stacksave() { |
| var self = _llvm_stacksave; |
| if (!self.LLVM_SAVEDSTACKS) { |
| self.LLVM_SAVEDSTACKS = []; |
| } |
| self.LLVM_SAVEDSTACKS.push(stackSave()); |
| return self.LLVM_SAVEDSTACKS.length-1; |
| } |
| |
| |
| function _emscripten_memcpy_big(dest, src, num) { |
| HEAPU8.set(HEAPU8.subarray(src, src+num), dest); |
| } |
| |
| |
| |
| |
| |
| |
| |
| FS.staticInit();Module["FS_createFolder"] = FS.createFolder;Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createLink"] = FS.createLink;Module["FS_createDevice"] = FS.createDevice;Module["FS_unlink"] = FS.unlink;; |
| var ASSERTIONS = true; |
| |
| // Copyright 2017 The Emscripten Authors. All rights reserved. |
| // Emscripten is available under two separate licenses, the MIT license and the |
| // University of Illinois/NCSA Open Source License. Both these licenses can be |
| // found in the LICENSE file. |
| |
| /** @type {function(string, boolean=, number=)} */ |
| function intArrayFromString(stringy, dontAddNull, length) { |
| var len = length > 0 ? length : lengthBytesUTF8(stringy)+1; |
| var u8array = new Array(len); |
| var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); |
| if (dontAddNull) u8array.length = numBytesWritten; |
| return u8array; |
| } |
| |
| function intArrayToString(array) { |
| var ret = []; |
| for (var i = 0; i < array.length; i++) { |
| var chr = array[i]; |
| if (chr > 0xFF) { |
| if (ASSERTIONS) { |
| assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.'); |
| } |
| chr &= 0xFF; |
| } |
| ret.push(String.fromCharCode(chr)); |
| } |
| return ret.join(''); |
| } |
| |
| |
| // ASM_LIBRARY EXTERN PRIMITIVES: Int8Array,Int32Array |
| |
| function nullFunc_ii(x) { abortFnPtrError(x, 'ii'); } |
| function nullFunc_iidiiii(x) { abortFnPtrError(x, 'iidiiii'); } |
| function nullFunc_iii(x) { abortFnPtrError(x, 'iii'); } |
| function nullFunc_iiii(x) { abortFnPtrError(x, 'iiii'); } |
| function nullFunc_jiji(x) { abortFnPtrError(x, 'jiji'); } |
| function nullFunc_vi(x) { abortFnPtrError(x, 'vi'); } |
| function nullFunc_vii(x) { abortFnPtrError(x, 'vii'); } |
| |
| function jsCall_ii(index,a1) { |
| return functionPointers[index](a1); |
| } |
| |
| function jsCall_iidiiii(index,a1,a2,a3,a4,a5,a6) { |
| return functionPointers[index](a1,a2,a3,a4,a5,a6); |
| } |
| |
| function jsCall_iii(index,a1,a2) { |
| return functionPointers[index](a1,a2); |
| } |
| |
| function jsCall_iiii(index,a1,a2,a3) { |
| return functionPointers[index](a1,a2,a3); |
| } |
| |
| function jsCall_jiji(index,a1,a2,a3) { |
| return functionPointers[index](a1,a2,a3); |
| } |
| |
| function jsCall_vi(index,a1) { |
| functionPointers[index](a1); |
| } |
| |
| function jsCall_vii(index,a1,a2) { |
| functionPointers[index](a1,a2); |
| } |
| |
| var asmGlobalArg = {}; |
| |
| var asmLibraryArg = { "___buildEnvironment": ___buildEnvironment, "___lock": ___lock, "___setErrNo": ___setErrNo, "___syscall195": ___syscall195, "___syscall220": ___syscall220, "___syscall221": ___syscall221, "___syscall5": ___syscall5, "___syscall54": ___syscall54, "___unlock": ___unlock, "___wasi_fd_close": ___wasi_fd_close, "___wasi_fd_read": ___wasi_fd_read, "___wasi_fd_seek": ___wasi_fd_seek, "___wasi_fd_write": ___wasi_fd_write, "__memory_base": 1024, "__table_base": 0, "_emscripten_get_heap_size": _emscripten_get_heap_size, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_emscripten_resize_heap": _emscripten_resize_heap, "_exit": _exit, "_fd_close": _fd_close, "_fd_read": _fd_read, "_fd_seek": _fd_seek, "_fd_write": _fd_write, "_getenv": _getenv, "_llvm_stackrestore": _llvm_stackrestore, "_llvm_stacksave": _llvm_stacksave, "abort": abort, "abortOnCannotGrowMemory": abortOnCannotGrowMemory, "abortStackOverflow": abortStackOverflow, "demangle": demangle, "demangleAll": demangleAll, "getTempRet0": getTempRet0, "jsCall_ii": jsCall_ii, "jsCall_iidiiii": jsCall_iidiiii, "jsCall_iii": jsCall_iii, "jsCall_iiii": jsCall_iiii, "jsCall_jiji": jsCall_jiji, "jsCall_vi": jsCall_vi, "jsCall_vii": jsCall_vii, "jsStackTrace": jsStackTrace, "memory": wasmMemory, "nullFunc_ii": nullFunc_ii, "nullFunc_iidiiii": nullFunc_iidiiii, "nullFunc_iii": nullFunc_iii, "nullFunc_iiii": nullFunc_iiii, "nullFunc_jiji": nullFunc_jiji, "nullFunc_vi": nullFunc_vi, "nullFunc_vii": nullFunc_vii, "setTempRet0": setTempRet0, "stackTrace": stackTrace, "table": wasmTable, "tempDoublePtr": tempDoublePtr }; |
| // EMSCRIPTEN_START_ASM |
| var asm =Module["asm"]// EMSCRIPTEN_END_ASM |
| (asmGlobalArg, asmLibraryArg, buffer); |
| |
| Module["asm"] = asm; |
| var ___emscripten_environ_constructor = Module["___emscripten_environ_constructor"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["___emscripten_environ_constructor"].apply(null, arguments) |
| }; |
| |
| var ___errno_location = Module["___errno_location"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["___errno_location"].apply(null, arguments) |
| }; |
| |
| var __get_environ = Module["__get_environ"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__get_environ"].apply(null, arguments) |
| }; |
| |
| var __lou_allocMem = Module["__lou_allocMem"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_allocMem"].apply(null, arguments) |
| }; |
| |
| var __lou_backTranslate = Module["__lou_backTranslate"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_backTranslate"].apply(null, arguments) |
| }; |
| |
| var __lou_charHash = Module["__lou_charHash"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_charHash"].apply(null, arguments) |
| }; |
| |
| var __lou_charToFallbackDots = Module["__lou_charToFallbackDots"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_charToFallbackDots"].apply(null, arguments) |
| }; |
| |
| var __lou_compileDisplayRule = Module["__lou_compileDisplayRule"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_compileDisplayRule"].apply(null, arguments) |
| }; |
| |
| var __lou_compileTranslationRule = Module["__lou_compileTranslationRule"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_compileTranslationRule"].apply(null, arguments) |
| }; |
| |
| var __lou_defaultTableResolver = Module["__lou_defaultTableResolver"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_defaultTableResolver"].apply(null, arguments) |
| }; |
| |
| var __lou_extParseChars = Module["__lou_extParseChars"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_extParseChars"].apply(null, arguments) |
| }; |
| |
| var __lou_extParseDots = Module["__lou_extParseDots"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_extParseDots"].apply(null, arguments) |
| }; |
| |
| var __lou_findOpcodeName = Module["__lou_findOpcodeName"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_findOpcodeName"].apply(null, arguments) |
| }; |
| |
| var __lou_findOpcodeNumber = Module["__lou_findOpcodeNumber"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_findOpcodeNumber"].apply(null, arguments) |
| }; |
| |
| var __lou_getALine = Module["__lou_getALine"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_getALine"].apply(null, arguments) |
| }; |
| |
| var __lou_getCharFromDots = Module["__lou_getCharFromDots"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_getCharFromDots"].apply(null, arguments) |
| }; |
| |
| var __lou_getDisplayTable = Module["__lou_getDisplayTable"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_getDisplayTable"].apply(null, arguments) |
| }; |
| |
| var __lou_getDotsForChar = Module["__lou_getDotsForChar"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_getDotsForChar"].apply(null, arguments) |
| }; |
| |
| var __lou_getTable = Module["__lou_getTable"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_getTable"].apply(null, arguments) |
| }; |
| |
| var __lou_getTablePath = Module["__lou_getTablePath"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_getTablePath"].apply(null, arguments) |
| }; |
| |
| var __lou_getTranslationTable = Module["__lou_getTranslationTable"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_getTranslationTable"].apply(null, arguments) |
| }; |
| |
| var __lou_handlePassVariableAction = Module["__lou_handlePassVariableAction"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_handlePassVariableAction"].apply(null, arguments) |
| }; |
| |
| var __lou_handlePassVariableTest = Module["__lou_handlePassVariableTest"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_handlePassVariableTest"].apply(null, arguments) |
| }; |
| |
| var __lou_isValidMode = Module["__lou_isValidMode"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_isValidMode"].apply(null, arguments) |
| }; |
| |
| var __lou_logMessage = Module["__lou_logMessage"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_logMessage"].apply(null, arguments) |
| }; |
| |
| var __lou_logWidecharBuf = Module["__lou_logWidecharBuf"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_logWidecharBuf"].apply(null, arguments) |
| }; |
| |
| var __lou_outOfMemory = Module["__lou_outOfMemory"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_outOfMemory"].apply(null, arguments) |
| }; |
| |
| var __lou_pattern_check = Module["__lou_pattern_check"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_pattern_check"].apply(null, arguments) |
| }; |
| |
| var __lou_pattern_compile = Module["__lou_pattern_compile"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_pattern_compile"].apply(null, arguments) |
| }; |
| |
| var __lou_pattern_reverse = Module["__lou_pattern_reverse"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_pattern_reverse"].apply(null, arguments) |
| }; |
| |
| var __lou_resetPassVariables = Module["__lou_resetPassVariables"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_resetPassVariables"].apply(null, arguments) |
| }; |
| |
| var __lou_resolveTable = Module["__lou_resolveTable"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_resolveTable"].apply(null, arguments) |
| }; |
| |
| var __lou_showAttributes = Module["__lou_showAttributes"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_showAttributes"].apply(null, arguments) |
| }; |
| |
| var __lou_showDots = Module["__lou_showDots"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_showDots"].apply(null, arguments) |
| }; |
| |
| var __lou_showString = Module["__lou_showString"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_showString"].apply(null, arguments) |
| }; |
| |
| var __lou_stringHash = Module["__lou_stringHash"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_stringHash"].apply(null, arguments) |
| }; |
| |
| var __lou_translate = Module["__lou_translate"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_translate"].apply(null, arguments) |
| }; |
| |
| var __lou_unknownDots = Module["__lou_unknownDots"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["__lou_unknownDots"].apply(null, arguments) |
| }; |
| |
| var _defaultLogCallback = Module["_defaultLogCallback"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_defaultLogCallback"].apply(null, arguments) |
| }; |
| |
| var _emscripten_get_sbrk_ptr = Module["_emscripten_get_sbrk_ptr"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_emscripten_get_sbrk_ptr"].apply(null, arguments) |
| }; |
| |
| var _fflush = Module["_fflush"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_fflush"].apply(null, arguments) |
| }; |
| |
| var _free = Module["_free"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_free"].apply(null, arguments) |
| }; |
| |
| var _lou_backTranslate = Module["_lou_backTranslate"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_backTranslate"].apply(null, arguments) |
| }; |
| |
| var _lou_backTranslateString = Module["_lou_backTranslateString"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_backTranslateString"].apply(null, arguments) |
| }; |
| |
| var _lou_charSize = Module["_lou_charSize"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_charSize"].apply(null, arguments) |
| }; |
| |
| var _lou_charToDots = Module["_lou_charToDots"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_charToDots"].apply(null, arguments) |
| }; |
| |
| var _lou_checkTable = Module["_lou_checkTable"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_checkTable"].apply(null, arguments) |
| }; |
| |
| var _lou_compileString = Module["_lou_compileString"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_compileString"].apply(null, arguments) |
| }; |
| |
| var _lou_dotsToChar = Module["_lou_dotsToChar"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_dotsToChar"].apply(null, arguments) |
| }; |
| |
| var _lou_findTable = Module["_lou_findTable"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_findTable"].apply(null, arguments) |
| }; |
| |
| var _lou_findTables = Module["_lou_findTables"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_findTables"].apply(null, arguments) |
| }; |
| |
| var _lou_free = Module["_lou_free"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_free"].apply(null, arguments) |
| }; |
| |
| var _lou_getDataPath = Module["_lou_getDataPath"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_getDataPath"].apply(null, arguments) |
| }; |
| |
| var _lou_getEmphClasses = Module["_lou_getEmphClasses"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_getEmphClasses"].apply(null, arguments) |
| }; |
| |
| var _lou_getTable = Module["_lou_getTable"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_getTable"].apply(null, arguments) |
| }; |
| |
| var _lou_getTableInfo = Module["_lou_getTableInfo"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_getTableInfo"].apply(null, arguments) |
| }; |
| |
| var _lou_getTypeformForEmphClass = Module["_lou_getTypeformForEmphClass"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_getTypeformForEmphClass"].apply(null, arguments) |
| }; |
| |
| var _lou_hyphenate = Module["_lou_hyphenate"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_hyphenate"].apply(null, arguments) |
| }; |
| |
| var _lou_indexTables = Module["_lou_indexTables"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_indexTables"].apply(null, arguments) |
| }; |
| |
| var _lou_listTables = Module["_lou_listTables"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_listTables"].apply(null, arguments) |
| }; |
| |
| var _lou_logEnd = Module["_lou_logEnd"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_logEnd"].apply(null, arguments) |
| }; |
| |
| var _lou_logFile = Module["_lou_logFile"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_logFile"].apply(null, arguments) |
| }; |
| |
| var _lou_logPrint = Module["_lou_logPrint"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_logPrint"].apply(null, arguments) |
| }; |
| |
| var _lou_readCharFromFile = Module["_lou_readCharFromFile"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_readCharFromFile"].apply(null, arguments) |
| }; |
| |
| var _lou_registerLogCallback = Module["_lou_registerLogCallback"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_registerLogCallback"].apply(null, arguments) |
| }; |
| |
| var _lou_registerTableResolver = Module["_lou_registerTableResolver"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_registerTableResolver"].apply(null, arguments) |
| }; |
| |
| var _lou_setDataPath = Module["_lou_setDataPath"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_setDataPath"].apply(null, arguments) |
| }; |
| |
| var _lou_setLogLevel = Module["_lou_setLogLevel"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_setLogLevel"].apply(null, arguments) |
| }; |
| |
| var _lou_translate = Module["_lou_translate"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_translate"].apply(null, arguments) |
| }; |
| |
| var _lou_translatePrehyphenated = Module["_lou_translatePrehyphenated"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_translatePrehyphenated"].apply(null, arguments) |
| }; |
| |
| var _lou_translateString = Module["_lou_translateString"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_translateString"].apply(null, arguments) |
| }; |
| |
| var _lou_version = Module["_lou_version"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_lou_version"].apply(null, arguments) |
| }; |
| |
| var _malloc = Module["_malloc"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_malloc"].apply(null, arguments) |
| }; |
| |
| var _memcpy = Module["_memcpy"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_memcpy"].apply(null, arguments) |
| }; |
| |
| var _memmove = Module["_memmove"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_memmove"].apply(null, arguments) |
| }; |
| |
| var _memset = Module["_memset"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_memset"].apply(null, arguments) |
| }; |
| |
| var establishStackSpace = Module["establishStackSpace"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["establishStackSpace"].apply(null, arguments) |
| }; |
| |
| var stackAlloc = Module["stackAlloc"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["stackAlloc"].apply(null, arguments) |
| }; |
| |
| var stackRestore = Module["stackRestore"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["stackRestore"].apply(null, arguments) |
| }; |
| |
| var stackSave = Module["stackSave"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["stackSave"].apply(null, arguments) |
| }; |
| |
| var dynCall_ii = Module["dynCall_ii"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["dynCall_ii"].apply(null, arguments) |
| }; |
| |
| var dynCall_iidiiii = Module["dynCall_iidiiii"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["dynCall_iidiiii"].apply(null, arguments) |
| }; |
| |
| var dynCall_iii = Module["dynCall_iii"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["dynCall_iii"].apply(null, arguments) |
| }; |
| |
| var dynCall_iiii = Module["dynCall_iiii"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["dynCall_iiii"].apply(null, arguments) |
| }; |
| |
| var dynCall_jiji = Module["dynCall_jiji"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["dynCall_jiji"].apply(null, arguments) |
| }; |
| |
| var dynCall_vi = Module["dynCall_vi"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["dynCall_vi"].apply(null, arguments) |
| }; |
| |
| var dynCall_vii = Module["dynCall_vii"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["dynCall_vii"].apply(null, arguments) |
| }; |
| ; |
| |
| |
| |
| // === Auto-generated postamble setup entry stuff === |
| |
| Module['asm'] = asm; |
| |
| Module["intArrayFromString"] = intArrayFromString; |
| Module["intArrayToString"] = intArrayToString; |
| Module["ccall"] = ccall; |
| Module["cwrap"] = cwrap; |
| Module["setValue"] = setValue; |
| Module["getValue"] = getValue; |
| Module["allocate"] = allocate; |
| Module["getMemory"] = getMemory; |
| if (!Object.getOwnPropertyDescriptor(Module, "AsciiToString")) Module["AsciiToString"] = function() { abort("'AsciiToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "stringToAscii")) Module["stringToAscii"] = function() { abort("'stringToAscii' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "UTF8ArrayToString")) Module["UTF8ArrayToString"] = function() { abort("'UTF8ArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "UTF8ToString")) Module["UTF8ToString"] = function() { abort("'UTF8ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8Array")) Module["stringToUTF8Array"] = function() { abort("'stringToUTF8Array' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8")) Module["stringToUTF8"] = function() { abort("'stringToUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF8")) Module["lengthBytesUTF8"] = function() { abort("'lengthBytesUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| Module["UTF16ToString"] = UTF16ToString; |
| Module["stringToUTF16"] = stringToUTF16; |
| if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF16")) Module["lengthBytesUTF16"] = function() { abort("'lengthBytesUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "UTF32ToString")) Module["UTF32ToString"] = function() { abort("'UTF32ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF32")) Module["stringToUTF32"] = function() { abort("'stringToUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF32")) Module["lengthBytesUTF32"] = function() { abort("'lengthBytesUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8")) Module["allocateUTF8"] = function() { abort("'allocateUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "stackTrace")) Module["stackTrace"] = function() { abort("'stackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "addOnPreRun")) Module["addOnPreRun"] = function() { abort("'addOnPreRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "addOnInit")) Module["addOnInit"] = function() { abort("'addOnInit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "addOnPreMain")) Module["addOnPreMain"] = function() { abort("'addOnPreMain' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "addOnExit")) Module["addOnExit"] = function() { abort("'addOnExit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "addOnPostRun")) Module["addOnPostRun"] = function() { abort("'addOnPostRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "writeStringToMemory")) Module["writeStringToMemory"] = function() { abort("'writeStringToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "writeArrayToMemory")) Module["writeArrayToMemory"] = function() { abort("'writeArrayToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "writeAsciiToMemory")) Module["writeAsciiToMemory"] = function() { abort("'writeAsciiToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| Module["addRunDependency"] = addRunDependency; |
| Module["removeRunDependency"] = removeRunDependency; |
| if (!Object.getOwnPropertyDescriptor(Module, "ENV")) Module["ENV"] = function() { abort("'ENV' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| Module["FS"] = FS; |
| Module["FS_createFolder"] = FS.createFolder; |
| Module["FS_createPath"] = FS.createPath; |
| Module["FS_createDataFile"] = FS.createDataFile; |
| Module["FS_createPreloadedFile"] = FS.createPreloadedFile; |
| Module["FS_createLazyFile"] = FS.createLazyFile; |
| Module["FS_createLink"] = FS.createLink; |
| Module["FS_createDevice"] = FS.createDevice; |
| Module["FS_unlink"] = FS.unlink; |
| if (!Object.getOwnPropertyDescriptor(Module, "GL")) Module["GL"] = function() { abort("'GL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "dynamicAlloc")) Module["dynamicAlloc"] = function() { abort("'dynamicAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "loadDynamicLibrary")) Module["loadDynamicLibrary"] = function() { abort("'loadDynamicLibrary' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "loadWebAssemblyModule")) Module["loadWebAssemblyModule"] = function() { abort("'loadWebAssemblyModule' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "getLEB")) Module["getLEB"] = function() { abort("'getLEB' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "getFunctionTables")) Module["getFunctionTables"] = function() { abort("'getFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "alignFunctionTables")) Module["alignFunctionTables"] = function() { abort("'alignFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "registerFunctions")) Module["registerFunctions"] = function() { abort("'registerFunctions' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "addFunction")) Module["addFunction"] = function() { abort("'addFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "removeFunction")) Module["removeFunction"] = function() { abort("'removeFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "getFuncWrapper")) Module["getFuncWrapper"] = function() { abort("'getFuncWrapper' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "prettyPrint")) Module["prettyPrint"] = function() { abort("'prettyPrint' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "makeBigInt")) Module["makeBigInt"] = function() { abort("'makeBigInt' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "dynCall")) Module["dynCall"] = function() { abort("'dynCall' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "getCompilerSetting")) Module["getCompilerSetting"] = function() { abort("'getCompilerSetting' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "stackSave")) Module["stackSave"] = function() { abort("'stackSave' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "stackRestore")) Module["stackRestore"] = function() { abort("'stackRestore' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "stackAlloc")) Module["stackAlloc"] = function() { abort("'stackAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "establishStackSpace")) Module["establishStackSpace"] = function() { abort("'establishStackSpace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "print")) Module["print"] = function() { abort("'print' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "printErr")) Module["printErr"] = function() { abort("'printErr' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "getTempRet0")) Module["getTempRet0"] = function() { abort("'getTempRet0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "setTempRet0")) Module["setTempRet0"] = function() { abort("'setTempRet0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "callMain")) Module["callMain"] = function() { abort("'callMain' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Object.getOwnPropertyDescriptor(Module, "abort")) Module["abort"] = function() { abort("'abort' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| Module["Pointer_stringify"] = Pointer_stringify; |
| if (!Object.getOwnPropertyDescriptor(Module, "warnOnce")) Module["warnOnce"] = function() { abort("'warnOnce' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| Module["writeStackCookie"] = writeStackCookie; |
| Module["checkStackCookie"] = checkStackCookie; |
| Module["abortStackOverflow"] = abortStackOverflow;Module["ALLOC_NORMAL"] = ALLOC_NORMAL; |
| if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_STACK")) Object.defineProperty(Module, "ALLOC_STACK", { configurable: true, get: function() { abort("'ALLOC_STACK' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") } }); |
| if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_DYNAMIC")) Object.defineProperty(Module, "ALLOC_DYNAMIC", { configurable: true, get: function() { abort("'ALLOC_DYNAMIC' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") } }); |
| if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_NONE")) Object.defineProperty(Module, "ALLOC_NONE", { configurable: true, get: function() { abort("'ALLOC_NONE' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") } }); |
| Module["calledRun"] = calledRun; |
| |
| |
| |
| var calledRun; |
| |
| // Modularize mode returns a function, which can be called to |
| // create instances. The instances provide a then() method, |
| // must like a Promise, that receives a callback. The callback |
| // is called when the module is ready to run, with the module |
| // as a parameter. (Like a Promise, it also returns the module |
| // so you can use the output of .then(..)). |
| Module['then'] = function(func) { |
| // We may already be ready to run code at this time. if |
| // so, just queue a call to the callback. |
| if (calledRun) { |
| func(Module); |
| } else { |
| // we are not ready to call then() yet. we must call it |
| // at the same time we would call onRuntimeInitialized. |
| var old = Module['onRuntimeInitialized']; |
| Module['onRuntimeInitialized'] = function() { |
| if (old) old(); |
| func(Module); |
| }; |
| } |
| return Module; |
| }; |
| |
| /** |
| * @constructor |
| * @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 |
| }; |
| |
| |
| |
| |
| |
| /** @type {function(Array=)} */ |
| function run(args) { |
| args = args || arguments_; |
| |
| if (runDependencies > 0) { |
| return; |
| } |
| |
| writeStackCookie(); |
| |
| 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; |
| Module['calledRun'] = true; |
| |
| if (ABORT) return; |
| |
| initRuntime(); |
| |
| preMain(); |
| |
| if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); |
| |
| assert(!Module['_main'], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]'); |
| |
| postRun(); |
| } |
| |
| if (Module['setStatus']) { |
| Module['setStatus']('Running...'); |
| setTimeout(function() { |
| setTimeout(function() { |
| Module['setStatus'](''); |
| }, 1); |
| doRun(); |
| }, 1); |
| } else |
| { |
| doRun(); |
| } |
| checkStackCookie(); |
| } |
| Module['run'] = run; |
| |
| function checkUnflushedContent() { |
| // Compiler settings do not allow exiting the runtime, so flushing |
| // the streams is not possible. but in ASSERTIONS mode we check |
| // if there was something to flush, and if so tell the user they |
| // should request that the runtime be exitable. |
| // Normally we would not even include flush() at all, but in ASSERTIONS |
| // builds we do so just for this check, and here we see if there is any |
| // content to flush, that is, we check if there would have been |
| // something a non-ASSERTIONS build would have not seen. |
| // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0 |
| // mode (which has its own special function for this; otherwise, all |
| // the code is inside libc) |
| var print = out; |
| var printErr = err; |
| var has = false; |
| out = err = function(x) { |
| has = true; |
| } |
| try { // it doesn't matter if it fails |
| var flush = Module['_fflush']; |
| if (flush) flush(0); |
| // also flush in the JS FS layer |
| ['stdout', 'stderr'].forEach(function(name) { |
| var info = FS.analyzePath('/dev/' + name); |
| if (!info) return; |
| var stream = info.object; |
| var rdev = stream.rdev; |
| var tty = TTY.ttys[rdev]; |
| if (tty && tty.output && tty.output.length) { |
| has = true; |
| } |
| }); |
| } catch(e) {} |
| out = print; |
| err = printErr; |
| if (has) { |
| warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc.'); |
| } |
| } |
| |
| function exit(status, implicit) { |
| checkUnflushedContent(); |
| |
| // 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) { |
| // if exit() was called, we may warn the user if the runtime isn't actually being shut down |
| if (!implicit) { |
| err('program exited (with status: ' + status + '), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)'); |
| } |
| } else { |
| |
| 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()(); |
| } |
| } |
| |
| |
| noExitRuntime = true; |
| |
| run(); |
| |
| |
| |
| |
| |
| // {{MODULE_ADDITIONS}} |
| |
| |
| |
| |
| |
| return liblouisBuild |
| } |
| ); |
| })(); |
| if (typeof exports === 'object' && typeof module === 'object') |
| module.exports = liblouisBuild; |
| else if (typeof define === 'function' && define['amd']) |
| define([], function() { return liblouisBuild; }); |
| else if (typeof exports === 'object') |
| exports["liblouisBuild"] = liblouisBuild; |
| |
