| |
| var liblouisBuild = (function() { |
| var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; |
| 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": 7565, "filename": "/pt-pt-g1.utb"}, {"start": 7565, "audio": 0, "end": 397406, "filename": "/de-g2-core.cti"}, {"start": 397406, "audio": 0, "end": 398895, "filename": "/de-chess.ctb"}, {"start": 398895, "audio": 0, "end": 411319, "filename": "/cy-cy-g1.utb"}, {"start": 411319, "audio": 0, "end": 443705, "filename": "/no-no-latinLetterDef6Dots_diacritics.uti"}, {"start": 443705, "audio": 0, "end": 451485, "filename": "/fi.utb"}, {"start": 451485, "audio": 0, "end": 457168, "filename": "/fa-ir-g1.utb"}, {"start": 457168, "audio": 0, "end": 457715, "filename": "/cs.tbl"}, {"start": 457715, "audio": 0, "end": 471409, "filename": "/no-no.dis"}, {"start": 471409, "audio": 0, "end": 480029, "filename": "/Lv-Lv-g1.utb"}, {"start": 480029, "audio": 0, "end": 488764, "filename": "/sl-si-comp8.ctb"}, {"start": 488764, "audio": 0, "end": 494345, "filename": "/de-de-comp8.ctb"}, {"start": 494345, "audio": 0, "end": 494888, "filename": "/hy.tbl"}, {"start": 494888, "audio": 0, "end": 496624, "filename": "/ko-2006-g1.ctb"}, {"start": 496624, "audio": 0, "end": 503482, "filename": "/ar-ar-g1.utb"}, {"start": 503482, "audio": 0, "end": 1766000, "filename": "/zh-chn.ctb"}, {"start": 1766000, "audio": 0, "end": 1766549, "filename": "/vi.tbl"}, {"start": 1766549, "audio": 0, "end": 1778680, "filename": "/mn-MN-common.cti"}, {"start": 1778680, "audio": 0, "end": 1779968, "filename": "/hyph_pt_PT.dic"}, {"start": 1779968, "audio": 0, "end": 1780528, "filename": "/sa.tbl"}, {"start": 1780528, "audio": 0, "end": 1781173, "filename": "/de.tbl"}, {"start": 1781173, "audio": 0, "end": 1781712, "filename": "/eo.tbl"}, {"start": 1781712, "audio": 0, "end": 1782280, "filename": "/cy.tbl"}, {"start": 1782280, "audio": 0, "end": 1783261, "filename": "/litdigits6DotsPlusDot6.uti"}, {"start": 1783261, "audio": 0, "end": 1788812, "filename": "/ko.cti"}, {"start": 1788812, "audio": 0, "end": 1789700, "filename": "/mun.ctb"}, {"start": 1789700, "audio": 0, "end": 1790256, "filename": "/ar.tbl"}, {"start": 1790256, "audio": 0, "end": 1790379, "filename": "/hr-g1.tbl"}, {"start": 1790379, "audio": 0, "end": 1793305, "filename": "/eo-g1-x-system.ctb"}, {"start": 1793305, "audio": 0, "end": 1807596, "filename": "/fr-bfu-comp8.utb"}, {"start": 1807596, "audio": 0, "end": 1808137, "filename": "/ru.tbl"}, {"start": 1808137, "audio": 0, "end": 1810336, "filename": "/de-eurobrl6.dis"}, {"start": 1810336, "audio": 0, "end": 1851786, "filename": "/Makefile.in"}, {"start": 1851786, "audio": 0, "end": 1853921, "filename": "/en-us-comp6.ctb"}, {"start": 1853921, "audio": 0, "end": 1915319, "filename": "/hyph_da_DK.dic"}, {"start": 1915319, "audio": 0, "end": 1916535, "filename": "/mn-in-g1.utb"}, {"start": 1916535, "audio": 0, "end": 1938883, "filename": "/sk-chardefs.cti"}, {"start": 1938883, "audio": 0, "end": 2814987, "filename": "/hyph_hu_HU.dic"}, {"start": 2814987, "audio": 0, "end": 2815663, "filename": "/en_US.tbl"}, {"start": 2815663, "audio": 0, "end": 2840496, "filename": "/unicode-braille.utb"}, {"start": 2840496, "audio": 0, "end": 2843858, "filename": "/de-ch-accents.cti"}, {"start": 2843858, "audio": 0, "end": 2845603, "filename": "/de-de-g1.ctb"}, {"start": 2845603, "audio": 0, "end": 3888171, "filename": "/zh-tw.ctb"}, {"start": 3888171, "audio": 0, "end": 3888721, "filename": "/gd.tbl"}, {"start": 3888721, "audio": 0, "end": 3889342, "filename": "/no.tbl"}, {"start": 3889342, "audio": 0, "end": 3889885, "filename": "/mun.tbl"}, {"start": 3889885, "audio": 0, "end": 3890098, "filename": "/en_US-comp8-ext.tbl"}, {"start": 3890098, "audio": 0, "end": 3901320, "filename": "/malayalam.cti"}, {"start": 3901320, "audio": 0, "end": 3902212, "filename": "/kru.ctb"}, {"start": 3902212, "audio": 0, "end": 3925893, "filename": "/ko-g1-rules.cti"}, {"start": 3925893, "audio": 0, "end": 3926498, "filename": "/cvox-common.cti"}, {"start": 3926498, "audio": 0, "end": 3937462, "filename": "/sin.cti"}, {"start": 3937462, "audio": 0, "end": 3945024, "filename": "/cs-comp8.utb"}, {"start": 3945024, "audio": 0, "end": 3959643, "filename": "/cs-chardefs.cti"}, {"start": 3959643, "audio": 0, "end": 3960187, "filename": "/bg.tbl"}, {"start": 3960187, "audio": 0, "end": 3996654, "filename": "/hyph_en_US.dic"}, {"start": 3996654, "audio": 0, "end": 4003720, "filename": "/vi-g1.ctb"}, {"start": 4003720, "audio": 0, "end": 4190398, "filename": "/hyph_nn_NO.dic"}, {"start": 4190398, "audio": 0, "end": 4193226, "filename": "/de-de-accents.cti"}, {"start": 4193226, "audio": 0, "end": 4217014, "filename": "/en-us-comp8-ext.utb"}, {"start": 4217014, "audio": 0, "end": 4231393, "filename": "/de-chardefs6.cti"}, {"start": 4231393, "audio": 0, "end": 4244058, "filename": "/no-no-g2.ctb"}, {"start": 4244058, "audio": 0, "end": 4245123, "filename": "/digits6DotsPlusDot6.uti"}, {"start": 4245123, "audio": 0, "end": 4246478, "filename": "/sin.utb"}, {"start": 4246478, "audio": 0, "end": 4247695, "filename": "/gu-in-g1.utb"}, {"start": 4247695, "audio": 0, "end": 4249138, "filename": "/hr-digits.uti"}, {"start": 4249138, "audio": 0, "end": 4258400, "filename": "/no-no-chardefs6.uti"}, {"start": 4258400, "audio": 0, "end": 4273949, "filename": "/ukmaths_unicode_defs.cti"}, {"start": 4273949, "audio": 0, "end": 4275369, "filename": "/latinLetterDef6Dots.uti"}, {"start": 4275369, "audio": 0, "end": 4297833, "filename": "/el.ctb"}, {"start": 4297833, "audio": 0, "end": 4298370, "filename": "/ca.tbl"}, {"start": 4298370, "audio": 0, "end": 4306554, "filename": "/ga-g1.utb"}, {"start": 4306554, "audio": 0, "end": 4316921, "filename": "/bengali.cti"}, {"start": 4316921, "audio": 0, "end": 4317463, "filename": "/sl.tbl"}, {"start": 4317463, "audio": 0, "end": 4333699, "filename": "/hr-chardefs.cti"}, {"start": 4333699, "audio": 0, "end": 4334264, "filename": "/dra.tbl"}, {"start": 4334264, "audio": 0, "end": 4334824, "filename": "/gu.tbl"}, {"start": 4334824, "audio": 0, "end": 4350314, "filename": "/gr-pl-comp8.uti"}, {"start": 4350314, "audio": 0, "end": 4351204, "filename": "/pi.ctb"}, {"start": 4351204, "audio": 0, "end": 4387458, "filename": "/Makefile"}, {"start": 4387458, "audio": 0, "end": 4408932, "filename": "/nl-chardefs.uti"}, {"start": 4408932, "audio": 0, "end": 4409474, "filename": "/gez.tbl"}, {"start": 4409474, "audio": 0, "end": 4416402, "filename": "/ethio-g1.ctb"}, {"start": 4416402, "audio": 0, "end": 4420619, "filename": "/hyph_es_ES.dic"}, {"start": 4420619, "audio": 0, "end": 4421178, "filename": "/mr.tbl"}, {"start": 4421178, "audio": 0, "end": 4423223, "filename": "/en-ueb-math.ctb"}, {"start": 4423223, "audio": 0, "end": 4437550, "filename": "/da-dk-g26l.ctb"}, {"start": 4437550, "audio": 0, "end": 4439317, "filename": "/de-ch-g1.ctb"}, {"start": 4439317, "audio": 0, "end": 4446134, "filename": "/IPA.utb"}, {"start": 4446134, "audio": 0, "end": 4447795, "filename": "/no-no-8dot-fallback-6dot-g0.utb"}, {"start": 4447795, "audio": 0, "end": 4449012, "filename": "/np-in-g1.utb"}, {"start": 4449012, "audio": 0, "end": 4449930, "filename": "/digits6Dots.uti"}, {"start": 4449930, "audio": 0, "end": 4451664, "filename": "/ko-2006-g2.ctb"}, {"start": 4451664, "audio": 0, "end": 4479594, "filename": "/en-us-g2.ctb"}, {"start": 4479594, "audio": 0, "end": 4480484, "filename": "/dra.ctb"}, {"start": 4480484, "audio": 0, "end": 4483327, "filename": "/ru-letters.dis"}, {"start": 4483327, "audio": 0, "end": 4483867, "filename": "/pi.tbl"}, {"start": 4483867, "audio": 0, "end": 4493291, "filename": "/nl-NL-g0.utb"}, {"start": 4493291, "audio": 0, "end": 4500495, "filename": "/de-g0-core.uti"}, {"start": 4500495, "audio": 0, "end": 4503247, "filename": "/ru-unicode.dis"}, {"start": 4503247, "audio": 0, "end": 4503718, "filename": "/el.tbl"}, {"start": 4503718, "audio": 0, "end": 4509144, "filename": "/hy.ctb"}, {"start": 4509144, "audio": 0, "end": 4509686, "filename": "/tr.tbl"}, {"start": 4509686, "audio": 0, "end": 4512738, "filename": "/uk.utb"}, {"start": 4512738, "audio": 0, "end": 4514775, "filename": "/afr-za-g1.ctb"}, {"start": 4514775, "audio": 0, "end": 4518107, "filename": "/sr-g1.ctb"}, {"start": 4518107, "audio": 0, "end": 4526265, "filename": "/chardefs.cti"}, {"start": 4526265, "audio": 0, "end": 4533859, "filename": "/sv-1996.ctb"}, {"start": 4533859, "audio": 0, "end": 4535931, "filename": "/en-gb-comp8.ctb"}, {"start": 4535931, "audio": 0, "end": 4538536, "filename": "/sk-translation.cti"}, {"start": 4538536, "audio": 0, "end": 4539073, "filename": "/sr.tbl"}, {"start": 4539073, "audio": 0, "end": 4539638, "filename": "/ga.tbl"}, {"start": 4539638, "audio": 0, "end": 4551118, "filename": "/lt-6dot.utb"}, {"start": 4551118, "audio": 0, "end": 4558770, "filename": "/Pl-Pl-g1.utb"}, {"start": 4558770, "audio": 0, "end": 4566715, "filename": "/da-dk-g16.ctb"}, {"start": 4566715, "audio": 0, "end": 4599380, "filename": "/hu-hu-g2_exceptions.cti"}, {"start": 4599380, "audio": 0, "end": 4682905, "filename": "/hyph_nl_NL.dic"}, {"start": 4682905, "audio": 0, "end": 4691349, "filename": "/hr-translation.cti"}, {"start": 4691349, "audio": 0, "end": 4691909, "filename": "/as.tbl"}, {"start": 4691909, "audio": 0, "end": 4698965, "filename": "/he.ctb"}, {"start": 4698965, "audio": 0, "end": 4700799, "filename": "/printables.cti"}, {"start": 4700799, "audio": 0, "end": 4701450, "filename": "/en_GB.tbl"}, {"start": 4701450, "audio": 0, "end": 4703463, "filename": "/ru-chardefs.cti"}, {"start": 4703463, "audio": 0, "end": 4716902, "filename": "/da-dk-g08.ctb"}, {"start": 4716902, "audio": 0, "end": 4718184, "filename": "/es-g1.ctb"}, {"start": 4718184, "audio": 0, "end": 4719840, "filename": "/nl-BE.dis"}, {"start": 4719840, "audio": 0, "end": 4739178, "filename": "/no-no-8dot.utb"}, {"start": 4739178, "audio": 0, "end": 4740196, "filename": "/maketablelist.sh"}, {"start": 4740196, "audio": 0, "end": 4748300, "filename": "/en_CA.ctb"}, {"start": 4748300, "audio": 0, "end": 4756090, "filename": "/fi-fi.ctb"}, {"start": 4756090, "audio": 0, "end": 4768148, "filename": "/hu-chardefs.cti"}, {"start": 4768148, "audio": 0, "end": 4768693, "filename": "/mwr.tbl"}, {"start": 4768693, "audio": 0, "end": 4769373, "filename": "/zh_CHN.tbl"}, {"start": 4769373, "audio": 0, "end": 4813484, "filename": "/ur-pk-g2.ctb"}, {"start": 4813484, "audio": 0, "end": 4823278, "filename": "/en-ueb-g1.ctb"}, {"start": 4823278, "audio": 0, "end": 4831947, "filename": "/nl-BE-g0.utb"}, {"start": 4831947, "audio": 0, "end": 4832840, "filename": "/kok.ctb"}, {"start": 4832840, "audio": 0, "end": 4840964, "filename": "/iu-ca-g1.ctb"}, {"start": 4840964, "audio": 0, "end": 4842182, "filename": "/mr-in-g1.utb"}, {"start": 4842182, "audio": 0, "end": 5028860, "filename": "/hyph_nb_NO.dic"}, {"start": 5028860, "audio": 0, "end": 5029474, "filename": "/pt.tbl"}, {"start": 5029474, "audio": 0, "end": 5030747, "filename": "/mn-MN-g2.ctb"}, {"start": 5030747, "audio": 0, "end": 5031958, "filename": "/or-in-g1.utb"}, {"start": 5031958, "audio": 0, "end": 5041486, "filename": "/oriya.cti"}, {"start": 5041486, "audio": 0, "end": 5043018, "filename": "/ukmaths_single_cell_defs.cti"}, {"start": 5043018, "audio": 0, "end": 5054651, "filename": "/da-lt.ctb"}, {"start": 5054651, "audio": 0, "end": 5055210, "filename": "/awa.tbl"}, {"start": 5055210, "audio": 0, "end": 5064668, "filename": "/sv-1989.ctb"}, {"start": 5064668, "audio": 0, "end": 5065883, "filename": "/be-in-g1.utb"}, {"start": 5065883, "audio": 0, "end": 5066506, "filename": "/nl.tbl"}, {"start": 5066506, "audio": 0, "end": 5067723, "filename": "/si-in-g1.utb"}, {"start": 5067723, "audio": 0, "end": 5070941, "filename": "/tamil.cti"}, {"start": 5070941, "audio": 0, "end": 5085100, "filename": "/da-dk-g26l-lit.ctb"}, {"start": 5085100, "audio": 0, "end": 5087754, "filename": "/de-de-g2.ctb"}, {"start": 5087754, "audio": 0, "end": 5090072, "filename": "/sk-sk.utb"}, {"start": 5090072, "audio": 0, "end": 5090614, "filename": "/bh.tbl"}, {"start": 5090614, "audio": 0, "end": 5094977, "filename": "/en-us-g1.ctb"}, {"start": 5094977, "audio": 0, "end": 5100764, "filename": "/Es-Es-g1.utb"}, {"start": 5100764, "audio": 0, "end": 5101325, "filename": "/ml.tbl"}, {"start": 5101325, "audio": 0, "end": 5106193, "filename": "/Se-Se-g1.utb"}, {"start": 5106193, "audio": 0, "end": 5108631, "filename": "/en-us-brf.dis"}, {"start": 5108631, "audio": 0, "end": 5110263, "filename": "/en-us-comp8.ctb"}, {"start": 5110263, "audio": 0, "end": 5112381, "filename": "/tr-g1.ctb"}, {"start": 5112381, "audio": 0, "end": 5113597, "filename": "/pu-in-g1.utb"}, {"start": 5113597, "audio": 0, "end": 5130783, "filename": "/lt.ctb"}, {"start": 5130783, "audio": 0, "end": 5131401, "filename": "/nl_BE.tbl"}, {"start": 5131401, "audio": 0, "end": 5132620, "filename": "/sa-in-g1.utb"}, {"start": 5132620, "audio": 0, "end": 5133839, "filename": "/ks-in-g1.utb"}, {"start": 5133839, "audio": 0, "end": 5138454, "filename": "/hu-hu-comp8.ctb"}, {"start": 5138454, "audio": 0, "end": 5154002, "filename": "/marburg_unicode_defs.cti"}, {"start": 5154002, "audio": 0, "end": 5156116, "filename": "/ga-g2.ctb"}, {"start": 5156116, "audio": 0, "end": 5420377, "filename": "/zh-hk.ctb"}, {"start": 5420377, "audio": 0, "end": 5420913, "filename": "/sk.tbl"}, {"start": 5420913, "audio": 0, "end": 6093311, "filename": "/zhcn-g1.ctb"}, {"start": 6093311, "audio": 0, "end": 6093854, "filename": "/et.tbl"}, {"start": 6093854, "audio": 0, "end": 6095046, "filename": "/kh-in-g1.utb"}, {"start": 6095046, "audio": 0, "end": 6099773, "filename": "/hu-hu-g1.ctb"}, {"start": 6099773, "audio": 0, "end": 6101271, "filename": "/en-chess.ctb"}, {"start": 6101271, "audio": 0, "end": 6101562, "filename": "/zh_HK.tbl"}, {"start": 6101562, "audio": 0, "end": 6102121, "filename": "/ta.tbl"}, {"start": 6102121, "audio": 0, "end": 6102678, "filename": "/bra.tbl"}, {"start": 6102678, "audio": 0, "end": 6116741, "filename": "/no-no-generic.dis"}, {"start": 6116741, "audio": 0, "end": 6117299, "filename": "/ne.tbl"}, {"start": 6117299, "audio": 0, "end": 6122307, "filename": "/ro.ctb"}, {"start": 6122307, "audio": 0, "end": 6123811, "filename": "/haw-us-g1.ctb"}, {"start": 6123811, "audio": 0, "end": 6124350, "filename": "/ckb.tbl"}, {"start": 6124350, "audio": 0, "end": 6125566, "filename": "/hi-in-g1.utb"}, {"start": 6125566, "audio": 0, "end": 6136411, "filename": "/sl-si-g1.utb"}, {"start": 6136411, "audio": 0, "end": 6138000, "filename": "/ar-fa.utb"}, {"start": 6138000, "audio": 0, "end": 6164431, "filename": "/braille-patterns.cti"}, {"start": 6164431, "audio": 0, "end": 6184429, "filename": "/de-chardefs8.cti"}, {"start": 6184429, "audio": 0, "end": 6184987, "filename": "/sd.tbl"}, {"start": 6184987, "audio": 0, "end": 6190455, "filename": "/chr-us-g1.ctb"}, {"start": 6190455, "audio": 0, "end": 6197703, "filename": "/bo.ctb"}, {"start": 6197703, "audio": 0, "end": 6197831, "filename": "/lt-6dot.tbl"}, {"start": 6197831, "audio": 0, "end": 6211558, "filename": "/IPA-unicode-range.uti"}, {"start": 6211558, "audio": 0, "end": 6215015, "filename": "/ckb-translation.cti"}, {"start": 6215015, "audio": 0, "end": 6222997, "filename": "/da-dk-g16-lit.ctb"}, {"start": 6222997, "audio": 0, "end": 6223541, "filename": "/kru.tbl"}, {"start": 6223541, "audio": 0, "end": 6224960, "filename": "/compress.cti"}, {"start": 6224960, "audio": 0, "end": 6225917, "filename": "/litdigits6Dots.uti"}, {"start": 6225917, "audio": 0, "end": 6238895, "filename": "/da-dk-6miscChars.cti"}, {"start": 6238895, "audio": 0, "end": 6262341, "filename": "/gr-bb.ctb"}, {"start": 6262341, "audio": 0, "end": 6266647, "filename": "/cy-cy-g2.ctb"}, {"start": 6266647, "audio": 0, "end": 6271936, "filename": "/gd.ctb"}, {"start": 6271936, "audio": 0, "end": 6282603, "filename": "/hyph_eo.dic"}, {"start": 6282603, "audio": 0, "end": 6283580, "filename": "/ca-g1.ctb"}, {"start": 6283580, "audio": 0, "end": 6288911, "filename": "/cs-letterDef8Dots.uti"}, {"start": 6288911, "audio": 0, "end": 6290684, "filename": "/mn-MN-g1.utb"}, {"start": 6290684, "audio": 0, "end": 6299083, "filename": "/fi-fi-8dot.ctb"}, {"start": 6299083, "audio": 0, "end": 6305513, "filename": "/bg.ctb"}, {"start": 6305513, "audio": 0, "end": 6306139, "filename": "/hu.tbl"}, {"start": 6306139, "audio": 0, "end": 6317129, "filename": "/fr-bfu-comp6.utb"}, {"start": 6317129, "audio": 0, "end": 6331745, "filename": "/uni-text.dis"}, {"start": 6331745, "audio": 0, "end": 6348997, "filename": "/pl-pl-comp8.ctb"}, {"start": 6348997, "audio": 0, "end": 6349907, "filename": "/gon.ctb"}, {"start": 6349907, "audio": 0, "end": 6364508, "filename": "/de-de.dis"}, {"start": 6364508, "audio": 0, "end": 6395059, "filename": "/hyph_pl_PL.dic"}, {"start": 6395059, "audio": 0, "end": 6396104, "filename": "/controlchars.cti"}, {"start": 6396104, "audio": 0, "end": 7105683, "filename": "/unicodedefs.cti"}, {"start": 7105683, "audio": 0, "end": 7107081, "filename": "/latinLetterDef8Dots.uti"}, {"start": 7107081, "audio": 0, "end": 7107623, "filename": "/mt.tbl"}, {"start": 7107623, "audio": 0, "end": 7108664, "filename": "/sot-za-g1.ctb"}, {"start": 7108664, "audio": 0, "end": 7123357, "filename": "/se-se.dis"}, {"start": 7123357, "audio": 0, "end": 7136288, "filename": "/hu-hu-g2.ctb"}, {"start": 7136288, "audio": 0, "end": 7136868, "filename": "/pl.tbl"}, {"start": 7136868, "audio": 0, "end": 7148866, "filename": "/vi.ctb"}, {"start": 7148866, "audio": 0, "end": 7159383, "filename": "/hr-comp8.utb"}, {"start": 7159383, "audio": 0, "end": 7160723, "filename": "/cs-g1.ctb"}, {"start": 7160723, "audio": 0, "end": 7162384, "filename": "/ko-g2.ctb"}, {"start": 7162384, "audio": 0, "end": 7162929, "filename": "/fi.tbl"}, {"start": 7162929, "audio": 0, "end": 7168177, "filename": "/sk-sk-g1.utb"}, {"start": 7168177, "audio": 0, "end": 7176873, "filename": "/kannada.cti"}, {"start": 7176873, "audio": 0, "end": 7188384, "filename": "/fi2.ctb"}, {"start": 7188384, "audio": 0, "end": 7332719, "filename": "/fr-bfu-g2.ctb"}, {"start": 7332719, "audio": 0, "end": 7333278, "filename": "/kn.tbl"}, {"start": 7333278, "audio": 0, "end": 7333820, "filename": "/lt.tbl"}, {"start": 7333820, "audio": 0, "end": 7339251, "filename": "/nl-g0.uti"}, {"start": 7339251, "audio": 0, "end": 7348856, "filename": "/gujarati.cti"}, {"start": 7348856, "audio": 0, "end": 7359097, "filename": "/se-se.ctb"}, {"start": 7359097, "audio": 0, "end": 7359637, "filename": "/sv.tbl"}, {"start": 7359637, "audio": 0, "end": 7359928, "filename": "/zh_TW.tbl"}, {"start": 7359928, "audio": 0, "end": 7360854, "filename": "/loweredDigits6Dots.uti"}, {"start": 7360854, "audio": 0, "end": 7381292, "filename": "/en-us-mathtext.ctb"}, {"start": 7381292, "audio": 0, "end": 7382502, "filename": "/ckb-g1.ctb"}, {"start": 7382502, "audio": 0, "end": 7383438, "filename": "/loweredDigits8Dots.uti"}, {"start": 7383438, "audio": 0, "end": 7383980, "filename": "/bo.tbl"}, {"start": 7383980, "audio": 0, "end": 7396120, "filename": "/fr-bfu-comp68.cti"}, {"start": 7396120, "audio": 0, "end": 7397630, "filename": "/hr-g1.ctb"}, {"start": 7397630, "audio": 0, "end": 7401125, "filename": "/no-no-g0.utb"}, {"start": 7401125, "audio": 0, "end": 7412461, "filename": "/ru.ctb"}, {"start": 7412461, "audio": 0, "end": 7413353, "filename": "/ne.ctb"}, {"start": 7413353, "audio": 0, "end": 7420319, "filename": "/sr-chardefs.cti"}, {"start": 7420319, "audio": 0, "end": 7424229, "filename": "/ko-2006.cti"}, {"start": 7424229, "audio": 0, "end": 7445471, "filename": "/is-chardefs8.cti"}, {"start": 7445471, "audio": 0, "end": 7459413, "filename": "/en-ueb-chardefs.uti"}, {"start": 7459413, "audio": 0, "end": 7459956, "filename": "/ro.tbl"}, {"start": 7459956, "audio": 0, "end": 7488439, "filename": "/da-dk-g26.ctb"}, {"start": 7488439, "audio": 0, "end": 7493584, "filename": "/fa-ir-comp8.ctb"}, {"start": 7493584, "audio": 0, "end": 7513845, "filename": "/no-no-comp8.ctb"}, {"start": 7513845, "audio": 0, "end": 7515360, "filename": "/marburg_single_cell_defs.cti"}, {"start": 7515360, "audio": 0, "end": 7515521, "filename": "/README"}, {"start": 7515521, "audio": 0, "end": 7532017, "filename": "/nemethdefs.cti"}, {"start": 7532017, "audio": 0, "end": 7553760, "filename": "/hyph_cs_CZ.dic"}, {"start": 7553760, "audio": 0, "end": 7558796, "filename": "/et-g0.utb"}, {"start": 7558796, "audio": 0, "end": 7569101, "filename": "/boxes.ctb"}, {"start": 7569101, "audio": 0, "end": 7569660, "filename": "/bn.tbl"}, {"start": 7569660, "audio": 0, "end": 7571497, "filename": "/de-ch-g0.utb"}, {"start": 7571497, "audio": 0, "end": 7572095, "filename": "/en_CA.tbl"}, {"start": 7572095, "audio": 0, "end": 7572987, "filename": "/bh.ctb"}, {"start": 7572987, "audio": 0, "end": 7573915, "filename": "/digits8Dots.uti"}, {"start": 7573915, "audio": 0, "end": 7956263, "filename": "/ko-chars.cti"}, {"start": 7956263, "audio": 0, "end": 7957482, "filename": "/ml-in-g1.utb"}, {"start": 7957482, "audio": 0, "end": 7958642, "filename": "/de-ch-g2.ctb"}, {"start": 7958642, "audio": 0, "end": 7960428, "filename": "/de-de-g0.utb"}, {"start": 7960428, "audio": 0, "end": 7967858, "filename": "/is-chardefs6.cti"}, {"start": 7967858, "audio": 0, "end": 8009464, "filename": "/da-dk-g28.ctb"}, {"start": 8009464, "audio": 0, "end": 8010956, "filename": "/corrections.cti"}, {"start": 8010956, "audio": 0, "end": 8039657, "filename": "/it-it-comp8.utb"}, {"start": 8039657, "audio": 0, "end": 8061217, "filename": "/pt-pt-g2.ctb"}, {"start": 8061217, "audio": 0, "end": 8072835, "filename": "/da-dk-octobraille.dis"}, {"start": 8072835, "audio": 0, "end": 8074397, "filename": "/us-table.dis"}, {"start": 8074397, "audio": 0, "end": 8082621, "filename": "/ru-ru.dis"}, {"start": 8082621, "audio": 0, "end": 8083170, "filename": "/hr-comp8.tbl"}, {"start": 8083170, "audio": 0, "end": 8084385, "filename": "/ka-in-g1.utb"}, {"start": 8084385, "audio": 0, "end": 8084942, "filename": "/or.tbl"}, {"start": 8084942, "audio": 0, "end": 8085500, "filename": "/te.tbl"}, {"start": 8085500, "audio": 0, "end": 8116759, "filename": "/hyph_sv_SE.dic"}, {"start": 8116759, "audio": 0, "end": 8117304, "filename": "/is.tbl"}, {"start": 8117304, "audio": 0, "end": 8118517, "filename": "/te-in-g1.utb"}, {"start": 8118517, "audio": 0, "end": 8393118, "filename": "/ko-g2-rules.cti"}, {"start": 8393118, "audio": 0, "end": 8397223, "filename": "/et.ctb"}, {"start": 8397223, "audio": 0, "end": 8405983, "filename": "/ckb-chardefs.cti"}, {"start": 8405983, "audio": 0, "end": 9020111, "filename": "/zhcn-g2.ctb"}, {"start": 9020111, "audio": 0, "end": 9039862, "filename": "/da-dk-g26-lit.ctb"}, {"start": 9039862, "audio": 0, "end": 9041517, "filename": "/es-translation.cti"}, {"start": 9041517, "audio": 0, "end": 9042060, "filename": "/gon.tbl"}, {"start": 9042060, "audio": 0, "end": 9070122, "filename": "/en-us-interline.ctb"}, {"start": 9070122, "audio": 0, "end": 9106923, "filename": "/hyph_de_DE.dic"}, {"start": 9106923, "audio": 0, "end": 9107472, "filename": "/lv.tbl"}, {"start": 9107472, "audio": 0, "end": 9109129, "filename": "/ko-g1.ctb"}, {"start": 9109129, "audio": 0, "end": 9110345, "filename": "/as-in-g1.utb"}, {"start": 9110345, "audio": 0, "end": 9110906, "filename": "/mni.tbl"}, {"start": 9110906, "audio": 0, "end": 9290456, "filename": "/en-ueb-g2.ctb"}, {"start": 9290456, "audio": 0, "end": 9297279, "filename": "/es-old.dis"}, {"start": 9297279, "audio": 0, "end": 9299355, "filename": "/en-us-compbrl.ctb"}, {"start": 9299355, "audio": 0, "end": 9299896, "filename": "/he.tbl"}, {"start": 9299896, "audio": 0, "end": 9301112, "filename": "/aw-in-g1.utb"}, {"start": 9301112, "audio": 0, "end": 9311371, "filename": "/gurumuki.cti"}, {"start": 9311371, "audio": 0, "end": 9311930, "filename": "/pa.tbl"}, {"start": 9311930, "audio": 0, "end": 9315704, "filename": "/no-no-g1.ctb"}, {"start": 9315704, "audio": 0, "end": 9317188, "filename": "/spaces.ctb"}, {"start": 9317188, "audio": 0, "end": 9347286, "filename": "/da-dk-g28l.ctb"}, {"start": 9347286, "audio": 0, "end": 9359629, "filename": "/en-gb-g1.utb"}, {"start": 9359629, "audio": 0, "end": 9366458, "filename": "/es-new.dis"}, {"start": 9366458, "audio": 0, "end": 9368916, "filename": "/eo-g1.ctb"}, {"start": 9368916, "audio": 0, "end": 9372415, "filename": "/en-in-g1.ctb"}, {"start": 9372415, "audio": 0, "end": 9383836, "filename": "/ur-pk-g1.utb"}, {"start": 9383836, "audio": 0, "end": 9384414, "filename": "/es.tbl"}, {"start": 9384414, "audio": 0, "end": 9394565, "filename": "/telugu.cti"}, {"start": 9394565, "audio": 0, "end": 9468180, "filename": "/de-g1-core.cti"}, {"start": 9468180, "audio": 0, "end": 9470703, "filename": "/cs-translation.cti"}, {"start": 9470703, "audio": 0, "end": 9476714, "filename": "/Makefile.am"}, {"start": 9476714, "audio": 0, "end": 9496268, "filename": "/en-GB-g2.ctb"}, {"start": 9496268, "audio": 0, "end": 9502171, "filename": "/is.ctb"}, {"start": 9502171, "audio": 0, "end": 9503385, "filename": "/br-in-g1.utb"}, {"start": 9503385, "audio": 0, "end": 9505591, "filename": "/hyph_it_IT.dic"}, {"start": 9505591, "audio": 0, "end": 9518936, "filename": "/no-no-generic.ctb"}, {"start": 9518936, "audio": 0, "end": 9521993, "filename": "/pt-pt-comp8.ctb"}, {"start": 9521993, "audio": 0, "end": 9529972, "filename": "/hyph_fr_FR.dic"}, {"start": 9529972, "audio": 0, "end": 9535062, "filename": "/ru-litbrl.ctb"}, {"start": 9535062, "audio": 0, "end": 9536417, "filename": "/hu-backtranslate-correction.dis"}, {"start": 9536417, "audio": 0, "end": 9603953, "filename": "/hyph_ru.dic"}, {"start": 9603953, "audio": 0, "end": 9622280, "filename": "/no-no-g3.ctb"}, {"start": 9622280, "audio": 0, "end": 9622818, "filename": "/hi.tbl"}, {"start": 9622818, "audio": 0, "end": 9630637, "filename": "/no-no-braillo-047-01.dis"}, {"start": 9630637, "audio": 0, "end": 9635318, "filename": "/tr.ctb"}, {"start": 9635318, "audio": 0, "end": 9639801, "filename": "/it-it-comp6.utb"}, {"start": 9639801, "audio": 0, "end": 9642968, "filename": "/eurodefs.cti"}, {"start": 9642968, "audio": 0, "end": 9657626, "filename": "/ca-chardefs.cti"}, {"start": 9657626, "audio": 0, "end": 9658294, "filename": "/de_CH.tbl"}, {"start": 9658294, "audio": 0, "end": 9676853, "filename": "/wiskunde-chardefs.cti"}, {"start": 9676853, "audio": 0, "end": 9680733, "filename": "/ru-compbrl.ctb"}, {"start": 9680733, "audio": 0, "end": 9796495, "filename": "/hu-exceptionwords.cti"}, {"start": 9796495, "audio": 0, "end": 9803399, "filename": "/Es-Es-G0.utb"}, {"start": 9803399, "audio": 0, "end": 9805490, "filename": "/de-eurobrl6u.dis"}, {"start": 9805490, "audio": 0, "end": 9816984, "filename": "/fi1.ctb"}, {"start": 9816984, "audio": 0, "end": 9822958, "filename": "/unicode.dis"}, {"start": 9822958, "audio": 0, "end": 9827509, "filename": "/mt.ctb"}, {"start": 9827509, "audio": 0, "end": 9828402, "filename": "/mwr.ctb"}, {"start": 9828402, "audio": 0, "end": 9837701, "filename": "/devanagari.cti"}, {"start": 9837701, "audio": 0, "end": 9859351, "filename": "/text_nabcc.dis"}, {"start": 9859351, "audio": 0, "end": 9867654, "filename": "/da-dk.dis"}, {"start": 9867654, "audio": 0, "end": 9868212, "filename": "/kha.tbl"}, {"start": 9868212, "audio": 0, "end": 9871888, "filename": "/ukchardefs.cti"}, {"start": 9871888, "audio": 0, "end": 9886172, "filename": "/es-chardefs.cti"}, {"start": 9886172, "audio": 0, "end": 9887604, "filename": "/sk-g1.ctb"}, {"start": 9887604, "audio": 0, "end": 9894307, "filename": "/countries.cti"}, {"start": 9894307, "audio": 0, "end": 9904888, "filename": "/ru-ru-g1.utb"}, {"start": 9904888, "audio": 0, "end": 9905433, "filename": "/kok.tbl"}, {"start": 9905433, "audio": 0, "end": 9919508, "filename": "/da-dk-g18.ctb"}, {"start": 9919508, "audio": 0, "end": 9921055, "filename": "/mao-nz-g1.ctb"}, {"start": 9921055, "audio": 0, "end": 9977132, "filename": "/hyph_brl_da_dk.dic"}, {"start": 9977132, "audio": 0, "end": 9977715, "filename": "/it.tbl"}, {"start": 9977715, "audio": 0, "end": 9982628, "filename": "/ta-ta-g1.ctb"}, {"start": 9982628, "audio": 0, "end": 9983672, "filename": "/tsn-za-g1.ctb"}, {"start": 9983672, "audio": 0, "end": 9984558, "filename": "/ta.ctb"}], "remote_package_size": 9984558, "package_uuid": "27dac3f3-bc97-441f-9c56-50890c5cde65"}); |
| |
| })(); |
| |
| |
| |
| |
| // Sometimes an existing Module object exists with properties |
| // meant to overwrite the default module functionality. Here |
| // we collect those properties and reapply _after_ we configure |
| // the current environment's defaults to avoid having to be so |
| // defensive during initialization. |
| var moduleOverrides = {}; |
| var key; |
| for (key in Module) { |
| if (Module.hasOwnProperty(key)) { |
| moduleOverrides[key] = Module[key]; |
| } |
| } |
| |
| Module['arguments'] = []; |
| Module['thisProgram'] = './this.program'; |
| Module['quit'] = function(status, toThrow) { |
| throw toThrow; |
| }; |
| Module['preRun'] = []; |
| Module['postRun'] = []; |
| |
| // Determine the runtime environment we are in. You can customize this by |
| // setting the ENVIRONMENT setting at compile time (see settings.js). |
| |
| var ENVIRONMENT_IS_WEB = false; |
| var ENVIRONMENT_IS_WORKER = false; |
| var ENVIRONMENT_IS_NODE = false; |
| var ENVIRONMENT_IS_SHELL = false; |
| ENVIRONMENT_IS_WEB = typeof window === 'object'; |
| ENVIRONMENT_IS_WORKER = typeof importScripts === 'function'; |
| ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function' && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER; |
| ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; |
| |
| if (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)'); |
| } |
| |
| // Three configurations we can be running in: |
| // 1) We could be the application main() thread running in the main JS UI thread. (ENVIRONMENT_IS_WORKER == false and ENVIRONMENT_IS_PTHREAD == false) |
| // 2) We could be the application main() thread proxied to worker. (with Emscripten -s PROXY_TO_WORKER=1) (ENVIRONMENT_IS_WORKER == true, ENVIRONMENT_IS_PTHREAD == false) |
| // 3) We could be an application pthread running in a worker. (ENVIRONMENT_IS_WORKER == true and ENVIRONMENT_IS_PTHREAD == true) |
| |
| // `/` should be present at the end if `scriptDirectory` is not empty |
| var scriptDirectory = ''; |
| function locateFile(path) { |
| if (Module['locateFile']) { |
| return Module['locateFile'](path, scriptDirectory); |
| } else { |
| return scriptDirectory + path; |
| } |
| } |
| |
| if (ENVIRONMENT_IS_NODE) { |
| scriptDirectory = __dirname + '/'; |
| |
| // Expose functionality in the same simple way that the shells work |
| // Note that we pollute the global namespace here, otherwise we break in node |
| var nodeFS; |
| var nodePath; |
| |
| Module['read'] = function shell_read(filename, binary) { |
| var ret; |
| if (!nodeFS) nodeFS = require('fs'); |
| if (!nodePath) nodePath = require('path'); |
| filename = nodePath['normalize'](filename); |
| ret = nodeFS['readFileSync'](filename); |
| return binary ? ret : ret.toString(); |
| }; |
| |
| Module['readBinary'] = function readBinary(filename) { |
| var ret = Module['read'](filename, true); |
| if (!ret.buffer) { |
| ret = new Uint8Array(ret); |
| } |
| assert(ret.buffer); |
| return ret; |
| }; |
| |
| if (process['argv'].length > 1) { |
| Module['thisProgram'] = process['argv'][1].replace(/\\/g, '/'); |
| } |
| |
| Module['arguments'] = process['argv'].slice(2); |
| |
| // MODULARIZE will export the module in the proper place outside, we don't need to export here |
| |
| process['on']('uncaughtException', function(ex) { |
| // suppress ExitStatus exceptions from showing an error |
| if (!(ex instanceof ExitStatus)) { |
| throw ex; |
| } |
| }); |
| // Currently node will swallow unhandled rejections, but this behavior is |
| // deprecated, and in the future it will exit with error status. |
| process['on']('unhandledRejection', abort); |
| |
| Module['quit'] = function(status) { |
| process['exit'](status); |
| }; |
| |
| Module['inspect'] = function () { return '[Emscripten Module object]'; }; |
| } else |
| if (ENVIRONMENT_IS_SHELL) { |
| |
| |
| if (typeof read != 'undefined') { |
| Module['read'] = function shell_read(f) { |
| return read(f); |
| }; |
| } |
| |
| Module['readBinary'] = function readBinary(f) { |
| var data; |
| if (typeof readbuffer === 'function') { |
| return new Uint8Array(readbuffer(f)); |
| } |
| data = read(f, 'binary'); |
| assert(typeof data === 'object'); |
| return data; |
| }; |
| |
| if (typeof scriptArgs != 'undefined') { |
| Module['arguments'] = scriptArgs; |
| } else if (typeof arguments != 'undefined') { |
| Module['arguments'] = arguments; |
| } |
| |
| if (typeof quit === 'function') { |
| Module['quit'] = function(status) { |
| quit(status); |
| } |
| } |
| } else |
| if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { |
| if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled |
| scriptDirectory = self.location.href; |
| } else if (document.currentScript) { // web |
| scriptDirectory = document.currentScript.src; |
| } |
| // When MODULARIZE (and not _INSTANCE), this JS may be executed later, after document.currentScript |
| // is gone, so we saved it, and we use it here instead of any other info. |
| if (_scriptDir) { |
| scriptDirectory = _scriptDir; |
| } |
| // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. |
| // otherwise, slice off the final part of the url to find the script directory. |
| // if scriptDirectory does not contain a slash, lastIndexOf will return -1, |
| // and scriptDirectory will correctly be replaced with an empty string. |
| if (scriptDirectory.indexOf('blob:') !== 0) { |
| scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/')+1); |
| } else { |
| scriptDirectory = ''; |
| } |
| |
| |
| Module['read'] = function shell_read(url) { |
| var xhr = new XMLHttpRequest(); |
| xhr.open('GET', url, false); |
| xhr.send(null); |
| return xhr.responseText; |
| }; |
| |
| if (ENVIRONMENT_IS_WORKER) { |
| Module['readBinary'] = function readBinary(url) { |
| var xhr = new XMLHttpRequest(); |
| xhr.open('GET', url, false); |
| xhr.responseType = 'arraybuffer'; |
| xhr.send(null); |
| return new Uint8Array(xhr.response); |
| }; |
| } |
| |
| Module['readAsync'] = function readAsync(url, onload, onerror) { |
| var xhr = new XMLHttpRequest(); |
| xhr.open('GET', url, true); |
| xhr.responseType = 'arraybuffer'; |
| xhr.onload = function xhr_onload() { |
| if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 |
| onload(xhr.response); |
| return; |
| } |
| onerror(); |
| }; |
| xhr.onerror = onerror; |
| xhr.send(null); |
| }; |
| |
| Module['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. |
| // If the user provided Module.print or printErr, use that. Otherwise, |
| // console.log is checked first, as 'print' on the web will open a print dialogue |
| // printErr is preferable to console.warn (works better in shells) |
| // bind(console) is necessary to fix IE/Edge closed dev tools panel behavior. |
| var out = Module['print'] || (typeof console !== 'undefined' ? console.log.bind(console) : (typeof print !== 'undefined' ? print : null)); |
| var err = Module['printErr'] || (typeof printErr !== 'undefined' ? printErr : ((typeof console !== 'undefined' && console.warn.bind(console)) || out)); |
| |
| // Merge back in the overrides |
| for (key in moduleOverrides) { |
| if (moduleOverrides.hasOwnProperty(key)) { |
| Module[key] = moduleOverrides[key]; |
| } |
| } |
| // Free the object hierarchy contained in the overrides, this lets the GC |
| // reclaim data used e.g. in memoryInitializerRequest, which is a large typed array. |
| moduleOverrides = undefined; |
| |
| // perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message |
| 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'); |
| |
| |
| |
| // 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) { |
| assert(!staticSealed); |
| var ret = STATICTOP; |
| STATICTOP = (STATICTOP + size + 15) & -16; |
| assert(STATICTOP < TOTAL_MEMORY, 'not enough memory for static allocation - increase TOTAL_MEMORY'); |
| return ret; |
| } |
| |
| function dynamicAlloc(size) { |
| assert(DYNAMICTOP_PTR); |
| var ret = HEAP32[DYNAMICTOP_PTR>>2]; |
| var end = (ret + size + 15) & -16; |
| HEAP32[DYNAMICTOP_PTR>>2] = end; |
| if (end >= TOTAL_MEMORY) { |
| var success = enlargeMemory(); |
| if (!success) { |
| HEAP32[DYNAMICTOP_PTR>>2] = ret; |
| return 0; |
| } |
| } |
| return ret; |
| } |
| |
| function alignMemory(size, factor) { |
| if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default |
| var ret = size = Math.ceil(size / factor) * factor; |
| return ret; |
| } |
| |
| 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); |
| 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); |
| |
| // 'sig' parameter is only used on LLVM wasm backend |
| function addFunction(func, sig) { |
| if (typeof sig === 'undefined') { |
| err('warning: addFunction(): You should provide a wasm function signature string as a second argument. This is not necessary for asm.js and asm2wasm, but is required for the LLVM wasm backend, so it is recommended for full portability.'); |
| } |
| 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 = { |
| // FIXME backwards compatibility layer for ports. Support some Runtime.* |
| // for now, fix it there, then remove it from here. That way we |
| // can minimize any period of breakage. |
| dynCall: dynCall, // for SDL2 port |
| // 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 |
| |
| |
| |
| //======================================== |
| // 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); |
| } |
| } |
| |
| var globalScope = this; |
| |
| // Returns the C function with a specified identifier (for C++, you need to do manual name mangling) |
| function getCFunc(ident) { |
| var func = Module['_' + ident]; // closure exported function |
| assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported'); |
| return func; |
| } |
| |
| var JSfuncs = { |
| // Helpers for cwrap -- it can't refer to Runtime directly because it might |
| // be renamed by closure, instead it calls JSfuncs['stackSave'].body to find |
| // out what the minified function name is. |
| 'stackSave': function() { |
| stackSave() |
| }, |
| 'stackRestore': function() { |
| stackRestore() |
| }, |
| // type conversion from js to c |
| 'arrayToC' : function(arr) { |
| var ret = stackAlloc(arr.length); |
| writeArrayToMemory(arr, ret); |
| return ret; |
| }, |
| 'stringToC' : function(str) { |
| var ret = 0; |
| if (str !== null && str !== undefined && str !== 0) { // null string |
| // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0' |
| var len = (str.length << 2) + 1; |
| ret = stackAlloc(len); |
| stringToUTF8(str, ret, len); |
| } |
| return ret; |
| } |
| }; |
| |
| // For fast lookup of conversion functions |
| var toC = { |
| 'string': JSfuncs['stringToC'], 'array': JSfuncs['arrayToC'] |
| }; |
| |
| |
| // C calling interface. |
| function ccall(ident, returnType, argTypes, args, opts) { |
| function convertReturnValue(ret) { |
| if (returnType === 'string') return Pointer_stringify(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); |
| } |
| } |
| |
| /** @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; |
| } |
| |
| var ALLOC_NORMAL = 0; // Tries to use _malloc() |
| var ALLOC_STACK = 1; // Lives for the duration of the current function call |
| var ALLOC_STATIC = 2; // Cannot be freed |
| var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk |
| var ALLOC_NONE = 4; // Do not allocate |
| |
| // allocate(): This is for internal use. You can use it yourself as well, but the interface |
| // is a little tricky (see docs right below). The reason is that it is optimized |
| // for multiple syntaxes to save space in generated code. So you should |
| // normally not use allocate(), and instead allocate memory using _malloc(), |
| // initialize it with setValue(), and so forth. |
| // @slab: An array of data, or a number. If a number, then the size of the block to allocate, |
| // in *bytes* (note that this is sometimes confusing: the next parameter does not |
| // affect this!) |
| // @types: Either an array of types, one for each byte (or 0 if no type at that position), |
| // or a single type which is used for the entire block. This only matters if there |
| // is initial data - if @slab is a number, then this does not matter at all and is |
| // ignored. |
| // @allocator: How to allocate memory, see ALLOC_* |
| /** @type {function((TypedArray|Array<number>|number), string, number, number=)} */ |
| function allocate(slab, types, allocator, ptr) { |
| var zeroinit, size; |
| if (typeof slab === 'number') { |
| zeroinit = true; |
| size = slab; |
| } else { |
| zeroinit = false; |
| size = slab.length; |
| } |
| |
| var singleType = typeof types === 'string' ? types : null; |
| |
| var ret; |
| if (allocator == ALLOC_NONE) { |
| ret = ptr; |
| } else { |
| ret = [typeof _malloc === 'function' ? _malloc : staticAlloc, stackAlloc, staticAlloc, dynamicAlloc][allocator === undefined ? ALLOC_STATIC : 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 (!staticSealed) return staticAlloc(size); |
| if (!runtimeInitialized) return dynamicAlloc(size); |
| return _malloc(size); |
| } |
| |
| /** @type {function(number, number=)} */ |
| function Pointer_stringify(ptr, length) { |
| if (length === 0 || !ptr) return ''; |
| // Find the length, and check for UTF while doing so |
| var hasUtf = 0; |
| var t; |
| var i = 0; |
| while (1) { |
| assert(ptr + i < TOTAL_MEMORY); |
| t = HEAPU8[(((ptr)+(i))>>0)]; |
| hasUtf |= t; |
| if (t == 0 && !length) break; |
| i++; |
| if (length && i == length) break; |
| } |
| if (!length) length = i; |
| |
| var ret = ''; |
| |
| if (hasUtf < 128) { |
| var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack |
| var curr; |
| while (length > 0) { |
| curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK))); |
| ret = ret ? ret + curr : curr; |
| ptr += MAX_CHUNK; |
| length -= MAX_CHUNK; |
| } |
| return ret; |
| } |
| return UTF8ToString(ptr); |
| } |
| |
| // Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns |
| // a copy of that string as a Javascript String object. |
| |
| function AsciiToString(ptr) { |
| var str = ''; |
| while (1) { |
| var ch = HEAP8[((ptr++)>>0)]; |
| if (!ch) return str; |
| str += String.fromCharCode(ch); |
| } |
| } |
| |
| // 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; |
| function UTF8ArrayToString(u8Array, idx) { |
| var endPtr = idx; |
| // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. |
| // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. |
| while (u8Array[endPtr]) ++endPtr; |
| |
| if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) { |
| return UTF8Decoder.decode(u8Array.subarray(idx, endPtr)); |
| } else { |
| var u0, u1, u2, u3, u4, u5; |
| |
| var str = ''; |
| while (1) { |
| // For UTF8 byte structure, see: |
| // http://en.wikipedia.org/wiki/UTF-8#Description |
| // https://www.ietf.org/rfc/rfc2279.txt |
| // https://tools.ietf.org/html/rfc3629 |
| u0 = u8Array[idx++]; |
| if (!u0) return str; |
| if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } |
| u1 = u8Array[idx++] & 63; |
| if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } |
| u2 = u8Array[idx++] & 63; |
| if ((u0 & 0xF0) == 0xE0) { |
| u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; |
| } else { |
| u3 = u8Array[idx++] & 63; |
| if ((u0 & 0xF8) == 0xF0) { |
| u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | u3; |
| } else { |
| u4 = u8Array[idx++] & 63; |
| if ((u0 & 0xFC) == 0xF8) { |
| u0 = ((u0 & 3) << 24) | (u1 << 18) | (u2 << 12) | (u3 << 6) | u4; |
| } else { |
| u5 = u8Array[idx++] & 63; |
| u0 = ((u0 & 1) << 30) | (u1 << 24) | (u2 << 18) | (u3 << 12) | (u4 << 6) | u5; |
| } |
| } |
| } |
| if (u0 < 0x10000) { |
| str += String.fromCharCode(u0); |
| } else { |
| var ch = u0 - 0x10000; |
| str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); |
| } |
| } |
| } |
| } |
| |
| // Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns |
| // a copy of that string as a Javascript String object. |
| |
| function UTF8ToString(ptr) { |
| return UTF8ArrayToString(HEAPU8,ptr); |
| } |
| |
| // 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 (u <= 0x1FFFFF) { |
| if (outIdx + 3 >= endIdx) break; |
| outU8Array[outIdx++] = 0xF0 | (u >> 18); |
| outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); |
| outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); |
| outU8Array[outIdx++] = 0x80 | (u & 63); |
| } else if (u <= 0x3FFFFFF) { |
| if (outIdx + 4 >= endIdx) break; |
| outU8Array[outIdx++] = 0xF8 | (u >> 24); |
| outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63); |
| outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); |
| outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); |
| outU8Array[outIdx++] = 0x80 | (u & 63); |
| } else { |
| if (outIdx + 5 >= endIdx) break; |
| outU8Array[outIdx++] = 0xFC | (u >> 30); |
| outU8Array[outIdx++] = 0x80 | ((u >> 24) & 63); |
| outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63); |
| outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); |
| outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); |
| outU8Array[outIdx++] = 0x80 | (u & 63); |
| } |
| } |
| // Null-terminate the pointer to the buffer. |
| outU8Array[outIdx] = 0; |
| return outIdx - startIdx; |
| } |
| |
| // 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 if (u <= 0x1FFFFF) { |
| len += 4; |
| } else if (u <= 0x3FFFFFF) { |
| len += 5; |
| } else { |
| len += 6; |
| } |
| } |
| 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; |
| } |
| |
| function demangle(func) { |
| warnOnce('warning: build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling'); |
| return func; |
| } |
| |
| function demangleAll(text) { |
| var regex = |
| /__Z[\w\d_]+/g; |
| return text.replace(regex, |
| function(x) { |
| var y = demangle(x); |
| return x === y ? x : (y + ' [' + x + ']'); |
| }); |
| } |
| |
| function jsStackTrace() { |
| var err = new Error(); |
| if (!err.stack) { |
| // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown, |
| // so try that as a special-case. |
| try { |
| throw new Error(0); |
| } catch(e) { |
| err = e; |
| } |
| if (!err.stack) { |
| return '(no stack trace available)'; |
| } |
| } |
| return err.stack.toString(); |
| } |
| |
| function stackTrace() { |
| var js = jsStackTrace(); |
| if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace'](); |
| return demangleAll(js); |
| } |
| |
| // Memory management |
| |
| var PAGE_SIZE = 16384; |
| var WASM_PAGE_SIZE = 65536; |
| var ASMJS_PAGE_SIZE = 16777216; |
| var MIN_TOTAL_MEMORY = 16777216; |
| |
| function alignUp(x, multiple) { |
| if (x % multiple > 0) { |
| x += multiple - (x % multiple); |
| } |
| return x; |
| } |
| |
| var HEAP, |
| /** @type {ArrayBuffer} */ |
| buffer, |
| /** @type {Int8Array} */ |
| HEAP8, |
| /** @type {Uint8Array} */ |
| HEAPU8, |
| /** @type {Int16Array} */ |
| HEAP16, |
| /** @type {Uint16Array} */ |
| HEAPU16, |
| /** @type {Int32Array} */ |
| HEAP32, |
| /** @type {Uint32Array} */ |
| HEAPU32, |
| /** @type {Float32Array} */ |
| HEAPF32, |
| /** @type {Float64Array} */ |
| HEAPF64; |
| |
| function updateGlobalBuffer(buf) { |
| Module['buffer'] = buffer = buf; |
| } |
| |
| function updateGlobalBufferViews() { |
| Module['HEAP8'] = HEAP8 = new Int8Array(buffer); |
| Module['HEAP16'] = HEAP16 = new Int16Array(buffer); |
| Module['HEAP32'] = HEAP32 = new Int32Array(buffer); |
| Module['HEAPU8'] = HEAPU8 = new Uint8Array(buffer); |
| Module['HEAPU16'] = HEAPU16 = new Uint16Array(buffer); |
| Module['HEAPU32'] = HEAPU32 = new Uint32Array(buffer); |
| Module['HEAPF32'] = HEAPF32 = new Float32Array(buffer); |
| Module['HEAPF64'] = HEAPF64 = new Float64Array(buffer); |
| } |
| |
| var STATIC_BASE, STATICTOP, staticSealed; // static area |
| var STACK_BASE, STACKTOP, STACK_MAX; // stack area |
| var DYNAMIC_BASE, DYNAMICTOP_PTR; // dynamic area handled by sbrk |
| |
| STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0; |
| staticSealed = false; |
| |
| |
| // Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode. |
| function writeStackCookie() { |
| assert((STACK_MAX & 3) == 0); |
| HEAPU32[(STACK_MAX >> 2)-1] = 0x02135467; |
| HEAPU32[(STACK_MAX >> 2)-2] = 0x89BACDFE; |
| } |
| |
| function checkStackCookie() { |
| if (HEAPU32[(STACK_MAX >> 2)-1] != 0x02135467 || HEAPU32[(STACK_MAX >> 2)-2] != 0x89BACDFE) { |
| abort('Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x02135467, but received 0x' + HEAPU32[(STACK_MAX >> 2)-2].toString(16) + ' ' + HEAPU32[(STACK_MAX >> 2)-1].toString(16)); |
| } |
| // Also test the global address 0 for integrity. |
| if (HEAP32[0] !== 0x63736d65 /* 'emsc' */) throw 'Runtime error: The application has corrupted its heap memory area (address zero)!'; |
| } |
| |
| function abortStackOverflow(allocSize) { |
| abort('Stack overflow! Attempted to allocate ' + allocSize + ' bytes on the stack, but stack has only ' + (STACK_MAX - stackSave() + allocSize) + ' bytes available!'); |
| } |
| |
| |
| function abortOnCannotGrowMemory() { |
| abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 '); |
| } |
| |
| |
| function enlargeMemory() { |
| abortOnCannotGrowMemory(); |
| } |
| |
| |
| var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880; |
| var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 167772160; |
| if (TOTAL_MEMORY < TOTAL_STACK) err('TOTAL_MEMORY should be larger than TOTAL_STACK, was ' + TOTAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')'); |
| |
| // Initialize the runtime's memory |
| // check for full engine support (use string 'subarray' to avoid closure compiler confusion) |
| assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray !== undefined && Int32Array.prototype.set !== undefined, |
| 'JS engine does not provide full typed array support'); |
| |
| |
| |
| // Use a provided buffer, if there is one, or else allocate a new one |
| if (Module['buffer']) { |
| buffer = Module['buffer']; |
| assert(buffer.byteLength === TOTAL_MEMORY, 'provided buffer should be ' + TOTAL_MEMORY + ' bytes, but it is ' + buffer.byteLength); |
| } else { |
| // Use a WebAssembly memory where available |
| if (typeof WebAssembly === 'object' && typeof WebAssembly.Memory === 'function') { |
| assert(TOTAL_MEMORY % WASM_PAGE_SIZE === 0); |
| Module['wasmMemory'] = new WebAssembly.Memory({ 'initial': TOTAL_MEMORY / WASM_PAGE_SIZE, 'maximum': TOTAL_MEMORY / WASM_PAGE_SIZE }); |
| buffer = Module['wasmMemory'].buffer; |
| } else |
| { |
| buffer = new ArrayBuffer(TOTAL_MEMORY); |
| } |
| assert(buffer.byteLength === TOTAL_MEMORY); |
| Module['buffer'] = buffer; |
| } |
| updateGlobalBufferViews(); |
| |
| |
| function getTotalMemory() { |
| return TOTAL_MEMORY; |
| } |
| |
| // Endianness check (note: assumes compiler arch was little-endian) |
| HEAP32[0] = 0x63736d65; /* 'emsc' */ |
| HEAP16[1] = 0x6373; |
| if (HEAPU8[2] !== 0x73 || HEAPU8[3] !== 0x63) throw 'Runtime error: expected the system to be little-endian!'; |
| |
| function callRuntimeCallbacks(callbacks) { |
| while(callbacks.length > 0) { |
| var callback = callbacks.shift(); |
| if (typeof callback == 'function') { |
| callback(); |
| continue; |
| } |
| var func = callback.func; |
| if (typeof func === 'number') { |
| if (callback.arg === undefined) { |
| Module['dynCall_v'](func); |
| } else { |
| Module['dynCall_vi'](func, callback.arg); |
| } |
| } else { |
| func(callback.arg === undefined ? null : callback.arg); |
| } |
| } |
| } |
| |
| var __ATPRERUN__ = []; // functions called before the runtime is initialized |
| var __ATINIT__ = []; // functions called during startup |
| var __ATMAIN__ = []; // functions called when main() is to be run |
| var __ATEXIT__ = []; // functions called during shutdown |
| var __ATPOSTRUN__ = []; // functions called after the main() is called |
| |
| var runtimeInitialized = false; |
| var runtimeExited = false; |
| |
| |
| function preRun() { |
| // compatibility - merge in anything from Module['preRun'] at this time |
| if (Module['preRun']) { |
| if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; |
| while (Module['preRun'].length) { |
| addOnPreRun(Module['preRun'].shift()); |
| } |
| } |
| callRuntimeCallbacks(__ATPRERUN__); |
| } |
| |
| function ensureInitRuntime() { |
| checkStackCookie(); |
| if (runtimeInitialized) return; |
| runtimeInitialized = true; |
| callRuntimeCallbacks(__ATINIT__); |
| } |
| |
| function preMain() { |
| checkStackCookie(); |
| callRuntimeCallbacks(__ATMAIN__); |
| } |
| |
| function exitRuntime() { |
| checkStackCookie(); |
| callRuntimeCallbacks(__ATEXIT__); |
| runtimeExited = true; |
| } |
| |
| function postRun() { |
| checkStackCookie(); |
| // compatibility - merge in anything from Module['postRun'] at this time |
| if (Module['postRun']) { |
| if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; |
| while (Module['postRun'].length) { |
| addOnPostRun(Module['postRun'].shift()); |
| } |
| } |
| callRuntimeCallbacks(__ATPOSTRUN__); |
| } |
| |
| function addOnPreRun(cb) { |
| __ATPRERUN__.unshift(cb); |
| } |
| |
| function addOnInit(cb) { |
| __ATINIT__.unshift(cb); |
| } |
| |
| function addOnPreMain(cb) { |
| __ATMAIN__.unshift(cb); |
| } |
| |
| function addOnExit(cb) { |
| __ATEXIT__.unshift(cb); |
| } |
| |
| function addOnPostRun(cb) { |
| __ATPOSTRUN__.unshift(cb); |
| } |
| |
| // 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; |
| } |
| |
| 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 |
| |
| |
| |
| 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; |
| } |
| |
| |
| |
| |
| function integrateWasmJS() { |
| // wasm.js has several methods for creating the compiled code module here: |
| // * 'native-wasm' : use native WebAssembly support in the browser |
| // * 'interpret-s-expr': load s-expression code from a .wast and interpret |
| // * 'interpret-binary': load binary wasm and interpret |
| // * 'interpret-asm2wasm': load asm.js code, translate to wasm, and interpret |
| // * 'asmjs': no wasm, just load the asm.js code and use that (good for testing) |
| // The method is set at compile time (BINARYEN_METHOD) |
| // The method can be a comma-separated list, in which case, we will try the |
| // options one by one. Some of them can fail gracefully, and then we can try |
| // the next. |
| |
| // inputs |
| |
| var method = 'native-wasm'; |
| |
| var wasmTextFile = 'liblouis_wasm.wast'; |
| var wasmBinaryFile = 'liblouis_wasm.wasm'; |
| var asmjsCodeFile = 'liblouis_wasm.temp.asm.js'; |
| |
| if (!isDataURI(wasmTextFile)) { |
| wasmTextFile = locateFile(wasmTextFile); |
| } |
| if (!isDataURI(wasmBinaryFile)) { |
| wasmBinaryFile = locateFile(wasmBinaryFile); |
| } |
| if (!isDataURI(asmjsCodeFile)) { |
| asmjsCodeFile = locateFile(asmjsCodeFile); |
| } |
| |
| // utilities |
| |
| var wasmPageSize = 64*1024; |
| |
| var info = { |
| 'global': null, |
| 'env': null, |
| 'asm2wasm': asm2wasmImports, |
| 'parent': Module // Module inside wasm-js.cpp refers to wasm-js.cpp; this allows access to the outside program. |
| }; |
| |
| var exports = null; |
| |
| |
| function mergeMemory(newBuffer) { |
| // The wasm instance creates its memory. But static init code might have written to |
| // buffer already, including the mem init file, and we must copy it over in a proper merge. |
| // TODO: avoid this copy, by avoiding such static init writes |
| // TODO: in shorter term, just copy up to the last static init write |
| var oldBuffer = Module['buffer']; |
| if (newBuffer.byteLength < oldBuffer.byteLength) { |
| err('the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here'); |
| } |
| var oldView = new Int8Array(oldBuffer); |
| var newView = new Int8Array(newBuffer); |
| |
| |
| newView.set(oldView); |
| updateGlobalBuffer(newBuffer); |
| updateGlobalBufferViews(); |
| } |
| |
| function getBinary() { |
| try { |
| if (Module['wasmBinary']) { |
| return new Uint8Array(Module['wasmBinary']); |
| } |
| if (Module['readBinary']) { |
| return Module['readBinary'](wasmBinaryFile); |
| } else { |
| throw "both async and sync fetching of the wasm failed"; |
| } |
| } |
| catch (err) { |
| abort(err); |
| } |
| } |
| |
| function getBinaryPromise() { |
| // if we don't have the binary yet, and have the Fetch api, use that |
| // in some environments, like Electron's render process, Fetch api may be present, but have a different context than expected, let's only use it on the Web |
| if (!Module['wasmBinary'] && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === 'function') { |
| return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) { |
| if (!response['ok']) { |
| throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; |
| } |
| return response['arrayBuffer'](); |
| }).catch(function () { |
| return getBinary(); |
| }); |
| } |
| // Otherwise, getBinary should be able to get it synchronously |
| return new Promise(function(resolve, reject) { |
| resolve(getBinary()); |
| }); |
| } |
| |
| // do-method functions |
| |
| |
| function doNativeWasm(global, env, providedBuffer) { |
| if (typeof WebAssembly !== 'object') { |
| // when the method is just native-wasm, our error message can be very specific |
| abort('No WebAssembly support found. Build with -s WASM=0 to target JavaScript instead.'); |
| err('no native wasm support detected'); |
| return false; |
| } |
| // prepare memory import |
| if (!(Module['wasmMemory'] instanceof WebAssembly.Memory)) { |
| err('no native wasm Memory in use'); |
| return false; |
| } |
| env['memory'] = Module['wasmMemory']; |
| // Load the wasm module and create an instance of using native support in the JS engine. |
| info['global'] = { |
| 'NaN': NaN, |
| 'Infinity': Infinity |
| }; |
| info['global.Math'] = Math; |
| info['env'] = env; |
| // handle a generated wasm instance, receiving its exports and |
| // performing other necessary setup |
| function receiveInstance(instance, module) { |
| exports = instance.exports; |
| if (exports.memory) mergeMemory(exports.memory); |
| Module['asm'] = exports; |
| Module["usingWasm"] = true; |
| removeRunDependency('wasm-instantiate'); |
| } |
| addRunDependency('wasm-instantiate'); |
| |
| // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback |
| // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel |
| // to any other async startup actions they are performing. |
| if (Module['instantiateWasm']) { |
| try { |
| return Module['instantiateWasm'](info, receiveInstance); |
| } catch(e) { |
| err('Module.instantiateWasm callback failed with error: ' + e); |
| return false; |
| } |
| } |
| |
| // 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; |
| receiveInstance(output['instance'], output['module']); |
| } |
| function instantiateArrayBuffer(receiver) { |
| 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. |
| if (!Module['wasmBinary'] && |
| typeof WebAssembly.instantiateStreaming === 'function' && |
| !isDataURI(wasmBinaryFile) && |
| typeof fetch === 'function') { |
| WebAssembly.instantiateStreaming(fetch(wasmBinaryFile, { credentials: 'same-origin' }), info) |
| .then(receiveInstantiatedSource, function(reason) { |
| // We expect the most common failure cause to be a bad MIME type for the binary, |
| // in which case falling back to ArrayBuffer instantiation should work. |
| err('wasm streaming compile failed: ' + reason); |
| err('falling back to ArrayBuffer instantiation'); |
| instantiateArrayBuffer(receiveInstantiatedSource); |
| }); |
| } else { |
| instantiateArrayBuffer(receiveInstantiatedSource); |
| } |
| return {}; // no exports yet; we'll fill them in later |
| } |
| |
| |
| // We may have a preloaded value in Module.asm, save it |
| Module['asmPreload'] = Module['asm']; |
| |
| // Memory growth integration code |
| |
| var asmjsReallocBuffer = Module['reallocBuffer']; |
| |
| var wasmReallocBuffer = function(size) { |
| var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE; // In wasm, heap size must be a multiple of 64KB. In asm.js, they need to be multiples of 16MB. |
| size = alignUp(size, PAGE_MULTIPLE); // round up to wasm page size |
| var old = Module['buffer']; |
| var oldSize = old.byteLength; |
| if (Module["usingWasm"]) { |
| // native wasm support |
| try { |
| var result = Module['wasmMemory'].grow((size - oldSize) / wasmPageSize); // .grow() takes a delta compared to the previous size |
| if (result !== (-1 | 0)) { |
| // success in native wasm memory growth, get the buffer from the memory |
| return Module['buffer'] = Module['wasmMemory'].buffer; |
| } else { |
| return null; |
| } |
| } catch(e) { |
| console.error('Module.reallocBuffer: Attempted to grow from ' + oldSize + ' bytes to ' + size + ' bytes, but got error: ' + e); |
| return null; |
| } |
| } |
| }; |
| |
| Module['reallocBuffer'] = function(size) { |
| if (finalMethod === 'asmjs') { |
| return asmjsReallocBuffer(size); |
| } else { |
| return wasmReallocBuffer(size); |
| } |
| }; |
| |
| // we may try more than one; this is the final one, that worked and we are using |
| var finalMethod = ''; |
| |
| // Provide an "asm.js function" for the application, called to "link" the asm.js module. We instantiate |
| // the wasm module at that time, and it receives imports and provides exports and so forth, the app |
| // doesn't need to care that it is wasm or polyfilled wasm or asm.js. |
| |
| Module['asm'] = function(global, env, providedBuffer) { |
| // import table |
| if (!env['table']) { |
| var TABLE_SIZE = Module['wasmTableSize']; |
| if (TABLE_SIZE === undefined) TABLE_SIZE = 1024; // works in binaryen interpreter at least |
| var MAX_TABLE_SIZE = Module['wasmMaxTableSize']; |
| if (typeof WebAssembly === 'object' && typeof WebAssembly.Table === 'function') { |
| if (MAX_TABLE_SIZE !== undefined) { |
| env['table'] = new WebAssembly.Table({ 'initial': TABLE_SIZE, 'maximum': MAX_TABLE_SIZE, 'element': 'anyfunc' }); |
| } else { |
| env['table'] = new WebAssembly.Table({ 'initial': TABLE_SIZE, element: 'anyfunc' }); |
| } |
| } else { |
| env['table'] = new Array(TABLE_SIZE); // works in binaryen interpreter at least |
| } |
| Module['wasmTable'] = env['table']; |
| } |
| |
| if (!env['__memory_base']) { |
| env['__memory_base'] = Module['STATIC_BASE']; // tell the memory segments where to place themselves |
| } |
| if (!env['__table_base']) { |
| env['__table_base'] = 0; // table starts at 0 by default, in dynamic linking this will change |
| } |
| |
| // try the methods. each should return the exports if it succeeded |
| |
| var exports; |
| exports = doNativeWasm(global, env, providedBuffer); |
| |
| assert(exports, 'no binaryen method succeeded. consider enabling more options, like interpreting, if you want that: http://kripken.github.io/emscripten-site/docs/compiling/WebAssembly.html#binaryen-methods'); |
| |
| |
| return exports; |
| }; |
| |
| var methodHandler = Module['asm']; // note our method handler, as we may modify Module['asm'] later |
| } |
| |
| integrateWasmJS(); |
| |
| // === Body === |
| |
| var ASM_CONSTS = []; |
| |
| |
| |
| |
| |
| STATIC_BASE = GLOBAL_BASE; |
| |
| STATICTOP = STATIC_BASE + 43008; |
| /* global initializers */ __ATINIT__.push({ func: function() { ___emscripten_environ_constructor() } }); |
| |
| |
| |
| |
| |
| |
| |
| var STATIC_BUMP = 43008; |
| Module["STATIC_BASE"] = STATIC_BASE; |
| Module["STATIC_BUMP"] = STATIC_BUMP; |
| |
| /* no memory initializer */ |
| var tempDoublePtr = STATICTOP; STATICTOP += 16; |
| assert(tempDoublePtr % 8 == 0); |
| |
| function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much |
| HEAP8[tempDoublePtr] = HEAP8[ptr]; |
| HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; |
| HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; |
| HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; |
| } |
| |
| function copyTempDouble(ptr) { |
| HEAP8[tempDoublePtr] = HEAP8[ptr]; |
| HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; |
| HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; |
| HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; |
| HEAP8[tempDoublePtr+4] = HEAP8[ptr+4]; |
| HEAP8[tempDoublePtr+5] = HEAP8[ptr+5]; |
| HEAP8[tempDoublePtr+6] = HEAP8[ptr+6]; |
| HEAP8[tempDoublePtr+7] = HEAP8[ptr+7]; |
| } |
| |
| // {{PRE_LIBRARY}} |
| |
| |
| |
| 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'] = ENV['LOGNAME'] = 'web_user'; |
| ENV['PATH'] = '/'; |
| ENV['PWD'] = '/'; |
| ENV['HOME'] = '/home/web_user'; |
| ENV['LANG'] = 'C.UTF-8'; |
| ENV['_'] = Module['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 ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86}; |
| |
| var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"Cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Not a typewriter",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read only file system",31:"Too many links",32:"Broken pipe",33:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"}; |
| |
| 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={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); |
| },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.resolve(from).substr(1); |
| to = PATH.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/kripken/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/kripken/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(ERRNO_CODES.ENODEV); |
| } |
| 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(ERRNO_CODES.ENXIO); |
| } |
| 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(ERRNO_CODES.EIO); |
| } |
| if (result === undefined && bytesRead === 0) { |
| throw new FS.ErrnoError(ERRNO_CODES.EAGAIN); |
| } |
| 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(ERRNO_CODES.ENXIO); |
| } |
| var i = 0; |
| try { |
| if (offset === 0 && length === 0) { |
| // musl implements an fflush using a write of a NULL buffer of size 0 |
| stream.tty.ops.flush(stream.tty); |
| } else { |
| while (i < length) { |
| stream.tty.ops.put_char(stream.tty, buffer[offset+i]); |
| i++; |
| } |
| } |
| } catch (e) { |
| throw new FS.ErrnoError(ERRNO_CODES.EIO); |
| } |
| 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 = new Buffer(BUFSIZE); |
| var bytesRead = 0; |
| |
| var isPosixPlatform = (process.platform != 'win32'); // Node doesn't offer a direct check, so test by exclusion |
| |
| var fd = process.stdin.fd; |
| if (isPosixPlatform) { |
| // Linux and Mac cannot use process.stdin.fd (which isn't set up as sync) |
| var usingDevice = false; |
| try { |
| fd = fs.openSync('/dev/stdin', 'r'); |
| usingDevice = true; |
| } catch (e) {} |
| } |
| |
| try { |
| bytesRead = fs.readSync(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 (usingDevice) { fs.closeSync(fd); } |
| 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(ERRNO_CODES.EPERM); |
| } |
| 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) { |
| // If we are asked to expand the size of a file that already exists, revert to using a standard JS array to store the file |
| // instead of a typed array. This makes resizing the array more flexible because we can just .push() elements at the back to |
| // increase the size. |
| if (node.contents && node.contents.subarray && newCapacity > node.contents.length) { |
| node.contents = MEMFS.getFileDataAsRegularArray(node); |
| node.usedBytes = node.contents.length; // We might be writing to a lazy-loaded file which had overridden this property, so force-reset it. |
| } |
| |
| if (!node.contents || node.contents.subarray) { // Keep using a typed array if creating a new storage, or if old one was a typed array as well. |
| 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; |
| } |
| // Not using a typed array to back the file storage. Use a standard JS array instead. |
| if (!node.contents && newCapacity > 0) node.contents = []; |
| while (node.contents.length < newCapacity) node.contents.push(0); |
| },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[ERRNO_CODES.ENOENT]; |
| },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(ERRNO_CODES.ENOTEMPTY); |
| } |
| } |
| } |
| // 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(ERRNO_CODES.ENOTEMPTY); |
| } |
| 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(ERRNO_CODES.EINVAL); |
| } |
| 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) { |
| |
| 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) { // SEEK_CUR. |
| position += stream.position; |
| } else if (whence === 2) { // SEEK_END. |
| if (FS.isFile(stream.node.mode)) { |
| position += stream.node.usedBytes; |
| } |
| } |
| if (position < 0) { |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); |
| } |
| return position; |
| },allocate:function (stream, offset, length) { |
| MEMFS.expandFileStorage(stream.node, offset + length); |
| stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length); |
| },mmap:function (stream, buffer, offset, length, position, prot, flags) { |
| if (!FS.isFile(stream.node.mode)) { |
| throw new FS.ErrnoError(ERRNO_CODES.ENODEV); |
| } |
| 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 || 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; |
| ptr = _malloc(length); |
| if (!ptr) { |
| throw new FS.ErrnoError(ERRNO_CODES.ENOMEM); |
| } |
| 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(ERRNO_CODES.ENODEV); |
| } |
| 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 IDBFS={dbs:{},indexedDB:function () { |
| if (typeof indexedDB !== 'undefined') return indexedDB; |
| var ret = null; |
| if (typeof window === 'object') ret = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; |
| assert(ret, 'IDBFS used, but indexedDB not supported'); |
| return ret; |
| },DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function (mount) { |
| // reuse all of the core MEMFS functionality |
| return MEMFS.mount.apply(null, arguments); |
| },syncfs:function (mount, populate, callback) { |
| IDBFS.getLocalSet(mount, function(err, local) { |
| if (err) return callback(err); |
| |
| IDBFS.getRemoteSet(mount, function(err, remote) { |
| if (err) return callback(err); |
| |
| var src = populate ? remote : local; |
| var dst = populate ? local : remote; |
| |
| IDBFS.reconcile(src, dst, callback); |
| }); |
| }); |
| },getDB:function (name, callback) { |
| // check the cache first |
| var db = IDBFS.dbs[name]; |
| if (db) { |
| return callback(null, db); |
| } |
| |
| var req; |
| try { |
| req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION); |
| } catch (e) { |
| return callback(e); |
| } |
| if (!req) { |
| return callback("Unable to connect to IndexedDB"); |
| } |
| req.onupgradeneeded = function(e) { |
| var db = e.target.result; |
| var transaction = e.target.transaction; |
| |
| var fileStore; |
| |
| if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) { |
| fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME); |
| } else { |
| fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME); |
| } |
| |
| if (!fileStore.indexNames.contains('timestamp')) { |
| fileStore.createIndex('timestamp', 'timestamp', { unique: false }); |
| } |
| }; |
| req.onsuccess = function() { |
| db = req.result; |
| |
| // add to the cache |
| IDBFS.dbs[name] = db; |
| callback(null, db); |
| }; |
| req.onerror = function(e) { |
| callback(this.error); |
| e.preventDefault(); |
| }; |
| },getLocalSet:function (mount, callback) { |
| var entries = {}; |
| |
| function isRealDir(p) { |
| return p !== '.' && p !== '..'; |
| }; |
| function toAbsolute(root) { |
| return function(p) { |
| return PATH.join2(root, p); |
| } |
| }; |
| |
| var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint)); |
| |
| while (check.length) { |
| var path = check.pop(); |
| var stat; |
| |
| try { |
| stat = FS.stat(path); |
| } catch (e) { |
| return callback(e); |
| } |
| |
| if (FS.isDir(stat.mode)) { |
| check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path))); |
| } |
| |
| entries[path] = { timestamp: stat.mtime }; |
| } |
| |
| return callback(null, { type: 'local', entries: entries }); |
| },getRemoteSet:function (mount, callback) { |
| var entries = {}; |
| |
| IDBFS.getDB(mount.mountpoint, function(err, db) { |
| if (err) return callback(err); |
| |
| try { |
| var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly'); |
| transaction.onerror = function(e) { |
| callback(this.error); |
| e.preventDefault(); |
| }; |
| |
| var store = transaction.objectStore(IDBFS.DB_STORE_NAME); |
| var index = store.index('timestamp'); |
| |
| index.openKeyCursor().onsuccess = function(event) { |
| var cursor = event.target.result; |
| |
| if (!cursor) { |
| return callback(null, { type: 'remote', db: db, entries: entries }); |
| } |
| |
| entries[cursor.primaryKey] = { timestamp: cursor.key }; |
| |
| cursor.continue(); |
| }; |
| } catch (e) { |
| return callback(e); |
| } |
| }); |
| },loadLocalEntry:function (path, callback) { |
| var stat, node; |
| |
| try { |
| var lookup = FS.lookupPath(path); |
| node = lookup.node; |
| stat = FS.stat(path); |
| } catch (e) { |
| return callback(e); |
| } |
| |
| if (FS.isDir(stat.mode)) { |
| return callback(null, { timestamp: stat.mtime, mode: stat.mode }); |
| } else if (FS.isFile(stat.mode)) { |
| // Performance consideration: storing a normal JavaScript array to a IndexedDB is much slower than storing a typed array. |
| // Therefore always convert the file contents to a typed array first before writing the data to IndexedDB. |
| node.contents = MEMFS.getFileDataAsTypedArray(node); |
| return callback(null, { timestamp: stat.mtime, mode: stat.mode, contents: node.contents }); |
| } else { |
| return callback(new Error('node type not supported')); |
| } |
| },storeLocalEntry:function (path, entry, callback) { |
| try { |
| if (FS.isDir(entry.mode)) { |
| FS.mkdir(path, entry.mode); |
| } else if (FS.isFile(entry.mode)) { |
| FS.writeFile(path, entry.contents, { canOwn: true }); |
| } else { |
| return callback(new Error('node type not supported')); |
| } |
| |
| FS.chmod(path, entry.mode); |
| FS.utime(path, entry.timestamp, entry.timestamp); |
| } catch (e) { |
| return callback(e); |
| } |
| |
| callback(null); |
| },removeLocalEntry:function (path, callback) { |
| try { |
| var lookup = FS.lookupPath(path); |
| var stat = FS.stat(path); |
| |
| if (FS.isDir(stat.mode)) { |
| FS.rmdir(path); |
| } else if (FS.isFile(stat.mode)) { |
| FS.unlink(path); |
| } |
| } catch (e) { |
| return callback(e); |
| } |
| |
| callback(null); |
| },loadRemoteEntry:function (store, path, callback) { |
| var req = store.get(path); |
| req.onsuccess = function(event) { callback(null, event.target.result); }; |
| req.onerror = function(e) { |
| callback(this.error); |
| e.preventDefault(); |
| }; |
| },storeRemoteEntry:function (store, path, entry, callback) { |
| var req = store.put(entry, path); |
| req.onsuccess = function() { callback(null); }; |
| req.onerror = function(e) { |
| callback(this.error); |
| e.preventDefault(); |
| }; |
| },removeRemoteEntry:function (store, path, callback) { |
| var req = store.delete(path); |
| req.onsuccess = function() { callback(null); }; |
| req.onerror = function(e) { |
| callback(this.error); |
| e.preventDefault(); |
| }; |
| },reconcile:function (src, dst, callback) { |
| var total = 0; |
| |
| var create = []; |
| Object.keys(src.entries).forEach(function (key) { |
| var e = src.entries[key]; |
| var e2 = dst.entries[key]; |
| if (!e2 || e.timestamp > e2.timestamp) { |
| create.push(key); |
| total++; |
| } |
| }); |
| |
| var remove = []; |
| Object.keys(dst.entries).forEach(function (key) { |
| var e = dst.entries[key]; |
| var e2 = src.entries[key]; |
| if (!e2) { |
| remove.push(key); |
| total++; |
| } |
| }); |
| |
| if (!total) { |
| return callback(null); |
| } |
| |
| var errored = false; |
| var completed = 0; |
| var db = src.type === 'remote' ? src.db : dst.db; |
| var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite'); |
| var store = transaction.objectStore(IDBFS.DB_STORE_NAME); |
| |
| function done(err) { |
| if (err) { |
| if (!done.errored) { |
| done.errored = true; |
| return callback(err); |
| } |
| return; |
| } |
| if (++completed >= total) { |
| return callback(null); |
| } |
| }; |
| |
| transaction.onerror = function(e) { |
| done(this.error); |
| e.preventDefault(); |
| }; |
| |
| // sort paths in ascending order so directory entries are created |
| // before the files inside them |
| create.sort().forEach(function (path) { |
| if (dst.type === 'local') { |
| IDBFS.loadRemoteEntry(store, path, function (err, entry) { |
| if (err) return done(err); |
| IDBFS.storeLocalEntry(path, entry, done); |
| }); |
| } else { |
| IDBFS.loadLocalEntry(path, function (err, entry) { |
| if (err) return done(err); |
| IDBFS.storeRemoteEntry(store, path, entry, done); |
| }); |
| } |
| }); |
| |
| // sort paths in descending order so files are deleted before their |
| // parent directories |
| remove.sort().reverse().forEach(function(path) { |
| if (dst.type === 'local') { |
| IDBFS.removeLocalEntry(path, done); |
| } else { |
| IDBFS.removeRemoteEntry(store, path, done); |
| } |
| }); |
| }}; |
| |
| var NODEFS={isWindows:false,staticInit:function () { |
| NODEFS.isWindows = !!process.platform.match(/^win/); |
| var flags = process["binding"]("constants"); |
| // Node.js 4 compatibility: it has no namespaces for constants |
| if (flags["fs"]) { |
| flags = flags["fs"]; |
| } |
| NODEFS.flagsForNodeMap = { |
| "1024": flags["O_APPEND"], |
| "64": flags["O_CREAT"], |
| "128": flags["O_EXCL"], |
| "0": flags["O_RDONLY"], |
| "2": flags["O_RDWR"], |
| "4096": flags["O_SYNC"], |
| "512": flags["O_TRUNC"], |
| "1": flags["O_WRONLY"] |
| }; |
| },bufferFrom:function (arrayBuffer) { |
| // Node.js < 4.5 compatibility: Buffer.from does not support ArrayBuffer |
| // Buffer.from before 4.5 was just a method inherited from Uint8Array |
| // Buffer.alloc has been added with Buffer.from together, so check it instead |
| return Buffer.alloc ? Buffer.from(arrayBuffer) : new Buffer(arrayBuffer); |
| },mount:function (mount) { |
| assert(ENVIRONMENT_IS_NODE); |
| return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0); |
| },createNode:function (parent, name, mode, dev) { |
| if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) { |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); |
| } |
| var node = FS.createNode(parent, name, mode); |
| node.node_ops = NODEFS.node_ops; |
| node.stream_ops = NODEFS.stream_ops; |
| return node; |
| },getMode:function (path) { |
| var stat; |
| try { |
| stat = fs.lstatSync(path); |
| if (NODEFS.isWindows) { |
| // Node.js on Windows never represents permission bit 'x', so |
| // propagate read bits to execute bits |
| stat.mode = stat.mode | ((stat.mode & 292) >> 2); |
| } |
| } catch (e) { |
| if (!e.code) throw e; |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| return stat.mode; |
| },realPath:function (node) { |
| var parts = []; |
| while (node.parent !== node) { |
| parts.push(node.name); |
| node = node.parent; |
| } |
| parts.push(node.mount.opts.root); |
| parts.reverse(); |
| return PATH.join.apply(null, parts); |
| },flagsForNode:function (flags) { |
| flags &= ~0x200000 /*O_PATH*/; // Ignore this flag from musl, otherwise node.js fails to open the file. |
| flags &= ~0x800 /*O_NONBLOCK*/; // Ignore this flag from musl, otherwise node.js fails to open the file. |
| flags &= ~0x8000 /*O_LARGEFILE*/; // Ignore this flag from musl, otherwise node.js fails to open the file. |
| flags &= ~0x80000 /*O_CLOEXEC*/; // Some applications may pass it; it makes no sense for a single process. |
| var newFlags = 0; |
| for (var k in NODEFS.flagsForNodeMap) { |
| if (flags & k) { |
| newFlags |= NODEFS.flagsForNodeMap[k]; |
| flags ^= k; |
| } |
| } |
| |
| if (!flags) { |
| return newFlags; |
| } else { |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); |
| } |
| },node_ops:{getattr:function (node) { |
| var path = NODEFS.realPath(node); |
| var stat; |
| try { |
| stat = fs.lstatSync(path); |
| } catch (e) { |
| if (!e.code) throw e; |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096. |
| // See http://support.microsoft.com/kb/140365 |
| if (NODEFS.isWindows && !stat.blksize) { |
| stat.blksize = 4096; |
| } |
| if (NODEFS.isWindows && !stat.blocks) { |
| stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0; |
| } |
| return { |
| dev: stat.dev, |
| ino: stat.ino, |
| mode: stat.mode, |
| nlink: stat.nlink, |
| uid: stat.uid, |
| gid: stat.gid, |
| rdev: stat.rdev, |
| size: stat.size, |
| atime: stat.atime, |
| mtime: stat.mtime, |
| ctime: stat.ctime, |
| blksize: stat.blksize, |
| blocks: stat.blocks |
| }; |
| },setattr:function (node, attr) { |
| var path = NODEFS.realPath(node); |
| try { |
| if (attr.mode !== undefined) { |
| fs.chmodSync(path, attr.mode); |
| // update the common node structure mode as well |
| node.mode = attr.mode; |
| } |
| if (attr.timestamp !== undefined) { |
| var date = new Date(attr.timestamp); |
| fs.utimesSync(path, date, date); |
| } |
| if (attr.size !== undefined) { |
| fs.truncateSync(path, attr.size); |
| } |
| } catch (e) { |
| if (!e.code) throw e; |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| },lookup:function (parent, name) { |
| var path = PATH.join2(NODEFS.realPath(parent), name); |
| var mode = NODEFS.getMode(path); |
| return NODEFS.createNode(parent, name, mode); |
| },mknod:function (parent, name, mode, dev) { |
| var node = NODEFS.createNode(parent, name, mode, dev); |
| // create the backing node for this in the fs root as well |
| var path = NODEFS.realPath(node); |
| try { |
| if (FS.isDir(node.mode)) { |
| fs.mkdirSync(path, node.mode); |
| } else { |
| fs.writeFileSync(path, '', { mode: node.mode }); |
| } |
| } catch (e) { |
| if (!e.code) throw e; |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| return node; |
| },rename:function (oldNode, newDir, newName) { |
| var oldPath = NODEFS.realPath(oldNode); |
| var newPath = PATH.join2(NODEFS.realPath(newDir), newName); |
| try { |
| fs.renameSync(oldPath, newPath); |
| } catch (e) { |
| if (!e.code) throw e; |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| },unlink:function (parent, name) { |
| var path = PATH.join2(NODEFS.realPath(parent), name); |
| try { |
| fs.unlinkSync(path); |
| } catch (e) { |
| if (!e.code) throw e; |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| },rmdir:function (parent, name) { |
| var path = PATH.join2(NODEFS.realPath(parent), name); |
| try { |
| fs.rmdirSync(path); |
| } catch (e) { |
| if (!e.code) throw e; |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| },readdir:function (node) { |
| var path = NODEFS.realPath(node); |
| try { |
| return fs.readdirSync(path); |
| } catch (e) { |
| if (!e.code) throw e; |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| },symlink:function (parent, newName, oldPath) { |
| var newPath = PATH.join2(NODEFS.realPath(parent), newName); |
| try { |
| fs.symlinkSync(oldPath, newPath); |
| } catch (e) { |
| if (!e.code) throw e; |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| },readlink:function (node) { |
| var path = NODEFS.realPath(node); |
| try { |
| path = fs.readlinkSync(path); |
| path = NODEJS_PATH.relative(NODEJS_PATH.resolve(node.mount.opts.root), path); |
| return path; |
| } catch (e) { |
| if (!e.code) throw e; |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| }},stream_ops:{open:function (stream) { |
| var path = NODEFS.realPath(stream.node); |
| try { |
| if (FS.isFile(stream.node.mode)) { |
| stream.nfd = fs.openSync(path, NODEFS.flagsForNode(stream.flags)); |
| } |
| } catch (e) { |
| if (!e.code) throw e; |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| },close:function (stream) { |
| try { |
| if (FS.isFile(stream.node.mode) && stream.nfd) { |
| fs.closeSync(stream.nfd); |
| } |
| } catch (e) { |
| if (!e.code) throw e; |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| },read:function (stream, buffer, offset, length, position) { |
| // Node.js < 6 compatibility: node errors on 0 length reads |
| if (length === 0) return 0; |
| try { |
| return fs.readSync(stream.nfd, NODEFS.bufferFrom(buffer.buffer), offset, length, position); |
| } catch (e) { |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| },write:function (stream, buffer, offset, length, position) { |
| try { |
| return fs.writeSync(stream.nfd, NODEFS.bufferFrom(buffer.buffer), offset, length, position); |
| } catch (e) { |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| },llseek:function (stream, offset, whence) { |
| var position = offset; |
| if (whence === 1) { // SEEK_CUR. |
| position += stream.position; |
| } else if (whence === 2) { // SEEK_END. |
| if (FS.isFile(stream.node.mode)) { |
| try { |
| var stat = fs.fstatSync(stream.nfd); |
| position += stat.size; |
| } catch (e) { |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); |
| } |
| } |
| } |
| |
| if (position < 0) { |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); |
| } |
| |
| return position; |
| }}}; |
| |
| var WORKERFS={DIR_MODE:16895,FILE_MODE:33279,reader:null,mount:function (mount) { |
| assert(ENVIRONMENT_IS_WORKER); |
| if (!WORKERFS.reader) WORKERFS.reader = new FileReaderSync(); |
| var root = WORKERFS.createNode(null, '/', WORKERFS.DIR_MODE, 0); |
| var createdParents = {}; |
| function ensureParent(path) { |
| // return the parent node, creating subdirs as necessary |
| var parts = path.split('/'); |
| var parent = root; |
| for (var i = 0; i < parts.length-1; i++) { |
| var curr = parts.slice(0, i+1).join('/'); |
| // Issue 4254: Using curr as a node name will prevent the node |
| // from being found in FS.nameTable when FS.open is called on |
| // a path which holds a child of this node, |
| // given that all FS functions assume node names |
| // are just their corresponding parts within their given path, |
| // rather than incremental aggregates which include their parent's |
| // directories. |
| if (!createdParents[curr]) { |
| createdParents[curr] = WORKERFS.createNode(parent, parts[i], WORKERFS.DIR_MODE, 0); |
| } |
| parent = createdParents[curr]; |
| } |
| return parent; |
| } |
| function base(path) { |
| var parts = path.split('/'); |
| return parts[parts.length-1]; |
| } |
| // We also accept FileList here, by using Array.prototype |
| Array.prototype.forEach.call(mount.opts["files"] || [], function(file) { |
| WORKERFS.createNode(ensureParent(file.name), base(file.name), WORKERFS.FILE_MODE, 0, file, file.lastModifiedDate); |
| }); |
| (mount.opts["blobs"] || []).forEach(function(obj) { |
| WORKERFS.createNode(ensureParent(obj["name"]), base(obj["name"]), WORKERFS.FILE_MODE, 0, obj["data"]); |
| }); |
| (mount.opts["packages"] || []).forEach(function(pack) { |
| pack['metadata'].files.forEach(function(file) { |
| var name = file.filename.substr(1); // remove initial slash |
| WORKERFS.createNode(ensureParent(name), base(name), WORKERFS.FILE_MODE, 0, pack['blob'].slice(file.start, file.end)); |
| }); |
| }); |
| return root; |
| },createNode:function (parent, name, mode, dev, contents, mtime) { |
| var node = FS.createNode(parent, name, mode); |
| node.mode = mode; |
| node.node_ops = WORKERFS.node_ops; |
| node.stream_ops = WORKERFS.stream_ops; |
| node.timestamp = (mtime || new Date).getTime(); |
| assert(WORKERFS.FILE_MODE !== WORKERFS.DIR_MODE); |
| if (mode === WORKERFS.FILE_MODE) { |
| node.size = contents.size; |
| node.contents = contents; |
| } else { |
| node.size = 4096; |
| node.contents = {}; |
| } |
| if (parent) { |
| parent.contents[name] = node; |
| } |
| return node; |
| },node_ops:{getattr:function (node) { |
| return { |
| dev: 1, |
| ino: undefined, |
| mode: node.mode, |
| nlink: 1, |
| uid: 0, |
| gid: 0, |
| rdev: undefined, |
| size: node.size, |
| atime: new Date(node.timestamp), |
| mtime: new Date(node.timestamp), |
| ctime: new Date(node.timestamp), |
| blksize: 4096, |
| blocks: Math.ceil(node.size / 4096), |
| }; |
| },setattr:function (node, attr) { |
| if (attr.mode !== undefined) { |
| node.mode = attr.mode; |
| } |
| if (attr.timestamp !== undefined) { |
| node.timestamp = attr.timestamp; |
| } |
| },lookup:function (parent, name) { |
| throw new FS.ErrnoError(ERRNO_CODES.ENOENT); |
| },mknod:function (parent, name, mode, dev) { |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); |
| },rename:function (oldNode, newDir, newName) { |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); |
| },unlink:function (parent, name) { |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); |
| },rmdir:function (parent, name) { |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); |
| },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) { |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); |
| },readlink:function (node) { |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); |
| }},stream_ops:{read:function (stream, buffer, offset, length, position) { |
| if (position >= stream.node.size) return 0; |
| var chunk = stream.node.contents.slice(position, position + length); |
| var ab = WORKERFS.reader.readAsArrayBuffer(chunk); |
| buffer.set(new Uint8Array(ab), offset); |
| return chunk.size; |
| },write:function (stream, buffer, offset, length, position) { |
| throw new FS.ErrnoError(ERRNO_CODES.EIO); |
| },llseek:function (stream, offset, whence) { |
| var position = offset; |
| if (whence === 1) { // SEEK_CUR. |
| position += stream.position; |
| } else if (whence === 2) { // SEEK_END. |
| if (FS.isFile(stream.node.mode)) { |
| position += stream.node.size; |
| } |
| } |
| if (position < 0) { |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); |
| } |
| return position; |
| }}}; |
| |
| var _stdin=STATICTOP; STATICTOP += 16;; |
| |
| var _stdout=STATICTOP; STATICTOP += 16;; |
| |
| var _stderr=STATICTOP; STATICTOP += 16;;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.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(ERRNO_CODES.ELOOP); |
| } |
| |
| // 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.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(ERRNO_CODES.ELOOP); |
| } |
| } |
| } |
| } |
| |
| 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 ERRNO_CODES.EACCES; |
| } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) { |
| return ERRNO_CODES.EACCES; |
| } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) { |
| return ERRNO_CODES.EACCES; |
| } |
| return 0; |
| },mayLookup:function (dir) { |
| var err = FS.nodePermissions(dir, 'x'); |
| if (err) return err; |
| if (!dir.node_ops.lookup) return ERRNO_CODES.EACCES; |
| return 0; |
| },mayCreate:function (dir, name) { |
| try { |
| var node = FS.lookupNode(dir, name); |
| return ERRNO_CODES.EEXIST; |
| } 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 ERRNO_CODES.ENOTDIR; |
| } |
| if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { |
| return ERRNO_CODES.EBUSY; |
| } |
| } else { |
| if (FS.isDir(node.mode)) { |
| return ERRNO_CODES.EISDIR; |
| } |
| } |
| return 0; |
| },mayOpen:function (node, flags) { |
| if (!node) { |
| return ERRNO_CODES.ENOENT; |
| } |
| if (FS.isLink(node.mode)) { |
| return ERRNO_CODES.ELOOP; |
| } 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 ERRNO_CODES.EISDIR; |
| } |
| } |
| 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(ERRNO_CODES.EMFILE); |
| },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(ERRNO_CODES.ESPIPE); |
| }},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) { |
| var root = mountpoint === '/'; |
| var pseudo = !mountpoint; |
| var node; |
| |
| if (root && FS.root) { |
| throw new FS.ErrnoError(ERRNO_CODES.EBUSY); |
| } 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(ERRNO_CODES.EBUSY); |
| } |
| |
| if (!FS.isDir(node.mode)) { |
| throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR); |
| } |
| } |
| |
| 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(ERRNO_CODES.EINVAL); |
| } |
| |
| // 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(ERRNO_CODES.EINVAL); |
| } |
| var err = FS.mayCreate(parent, name); |
| if (err) { |
| throw new FS.ErrnoError(err); |
| } |
| if (!parent.node_ops.mknod) { |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); |
| } |
| 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 != ERRNO_CODES.EEXIST) 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.resolve(oldpath)) { |
| throw new FS.ErrnoError(ERRNO_CODES.ENOENT); |
| } |
| var lookup = FS.lookupPath(newpath, { parent: true }); |
| var parent = lookup.node; |
| if (!parent) { |
| throw new FS.ErrnoError(ERRNO_CODES.ENOENT); |
| } |
| 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(ERRNO_CODES.EPERM); |
| } |
| 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(ERRNO_CODES.EBUSY); |
| } |
| if (!old_dir || !new_dir) throw new FS.ErrnoError(ERRNO_CODES.ENOENT); |
| // need to be part of the same mount |
| if (old_dir.mount !== new_dir.mount) { |
| throw new FS.ErrnoError(ERRNO_CODES.EXDEV); |
| } |
| // 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.relative(old_path, new_dirname); |
| if (relative.charAt(0) !== '.') { |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); |
| } |
| // new path should not be an ancestor of the old path |
| relative = PATH.relative(new_path, old_dirname); |
| if (relative.charAt(0) !== '.') { |
| throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY); |
| } |
| // 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(ERRNO_CODES.EPERM); |
| } |
| if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) { |
| throw new FS.ErrnoError(ERRNO_CODES.EBUSY); |
| } |
| // 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(ERRNO_CODES.EPERM); |
| } |
| if (FS.isMountpoint(node)) { |
| throw new FS.ErrnoError(ERRNO_CODES.EBUSY); |
| } |
| 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(ERRNO_CODES.ENOTDIR); |
| } |
| 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(ERRNO_CODES.EPERM); |
| } |
| if (FS.isMountpoint(node)) { |
| throw new FS.ErrnoError(ERRNO_CODES.EBUSY); |
| } |
| 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(ERRNO_CODES.ENOENT); |
| } |
| if (!link.node_ops.readlink) { |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); |
| } |
| return PATH.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(ERRNO_CODES.ENOENT); |
| } |
| if (!node.node_ops.getattr) { |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); |
| } |
| 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(ERRNO_CODES.EPERM); |
| } |
| 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(ERRNO_CODES.EBADF); |
| } |
| 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(ERRNO_CODES.EPERM); |
| } |
| 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(ERRNO_CODES.EBADF); |
| } |
| FS.chown(stream.node, uid, gid); |
| },truncate:function (path, len) { |
| if (len < 0) { |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); |
| } |
| 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(ERRNO_CODES.EPERM); |
| } |
| if (FS.isDir(node.mode)) { |
| throw new FS.ErrnoError(ERRNO_CODES.EISDIR); |
| } |
| if (!FS.isFile(node.mode)) { |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); |
| } |
| 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(ERRNO_CODES.EBADF); |
| } |
| if ((stream.flags & 2097155) === 0) { |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); |
| } |
| 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(ERRNO_CODES.ENOENT); |
| } |
| 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(ERRNO_CODES.EEXIST); |
| } |
| } else { |
| // node doesn't exist, try to create it |
| node = FS.mknod(path, mode, 0); |
| created = true; |
| } |
| } |
| if (!node) { |
| throw new FS.ErrnoError(ERRNO_CODES.ENOENT); |
| } |
| // 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(ERRNO_CODES.ENOTDIR); |
| } |
| // 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(ERRNO_CODES.EBADF); |
| } |
| 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(ERRNO_CODES.EBADF); |
| } |
| if (!stream.seekable || !stream.stream_ops.llseek) { |
| throw new FS.ErrnoError(ERRNO_CODES.ESPIPE); |
| } |
| 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(ERRNO_CODES.EINVAL); |
| } |
| if (FS.isClosed(stream)) { |
| throw new FS.ErrnoError(ERRNO_CODES.EBADF); |
| } |
| if ((stream.flags & 2097155) === 1) { |
| throw new FS.ErrnoError(ERRNO_CODES.EBADF); |
| } |
| if (FS.isDir(stream.node.mode)) { |
| throw new FS.ErrnoError(ERRNO_CODES.EISDIR); |
| } |
| if (!stream.stream_ops.read) { |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); |
| } |
| var seeking = typeof position !== 'undefined'; |
| if (!seeking) { |
| position = stream.position; |
| } else if (!stream.seekable) { |
| throw new FS.ErrnoError(ERRNO_CODES.ESPIPE); |
| } |
| 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(ERRNO_CODES.EINVAL); |
| } |
| if (FS.isClosed(stream)) { |
| throw new FS.ErrnoError(ERRNO_CODES.EBADF); |
| } |
| if ((stream.flags & 2097155) === 0) { |
| throw new FS.ErrnoError(ERRNO_CODES.EBADF); |
| } |
| if (FS.isDir(stream.node.mode)) { |
| throw new FS.ErrnoError(ERRNO_CODES.EISDIR); |
| } |
| if (!stream.stream_ops.write) { |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); |
| } |
| 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(ERRNO_CODES.ESPIPE); |
| } |
| 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']('"+path+"') threw an exception: " + e.message); |
| } |
| return bytesWritten; |
| },allocate:function (stream, offset, length) { |
| if (FS.isClosed(stream)) { |
| throw new FS.ErrnoError(ERRNO_CODES.EBADF); |
| } |
| if (offset < 0 || length <= 0) { |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); |
| } |
| if ((stream.flags & 2097155) === 0) { |
| throw new FS.ErrnoError(ERRNO_CODES.EBADF); |
| } |
| if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { |
| throw new FS.ErrnoError(ERRNO_CODES.ENODEV); |
| } |
| if (!stream.stream_ops.allocate) { |
| throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP); |
| } |
| stream.stream_ops.allocate(stream, offset, length); |
| },mmap:function (stream, buffer, offset, length, position, prot, flags) { |
| // TODO if PROT is PROT_WRITE, make sure we have write access |
| if ((stream.flags & 2097155) === 1) { |
| throw new FS.ErrnoError(ERRNO_CODES.EACCES); |
| } |
| if (!stream.stream_ops.mmap) { |
| throw new FS.ErrnoError(ERRNO_CODES.ENODEV); |
| } |
| 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(ERRNO_CODES.ENOTTY); |
| } |
| 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(ERRNO_CODES.ENOENT); |
| } |
| if (!FS.isDir(lookup.node.mode)) { |
| throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR); |
| } |
| 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 !== 'undefined') { |
| // 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 |
| random_device = function() { return require('crypto')['randomBytes'](1)[0]; }; |
| } else { |
| // default for ES5 platforms |
| random_device = function() { abort("random_device"); /*Math.random() is not safe for random number generation, so this fallback random_device implementation aborts... see kripken/emscripten/pull/7096 */ }; |
| } |
| 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(ERRNO_CODES.EBADF); |
| 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'); |
| assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')'); |
| |
| var stdout = FS.open('/dev/stdout', 'w'); |
| assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')'); |
| |
| var stderr = FS.open('/dev/stderr', 'w'); |
| 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]; |
| // Node.js compatibility: assigning on this.stack fails on Node 4 (but fixed on Node 8) |
| if (this.stack) Object.defineProperty(this, "stack", { value: (new Error).stack, writable: true }); |
| if (this.stack) 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) |
| [ERRNO_CODES.ENOENT].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, |
| 'IDBFS': IDBFS, |
| 'NODEFS': NODEFS, |
| 'WORKERFS': WORKERFS, |
| }; |
| },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.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(ERRNO_CODES.EIO); |
| } |
| if (result === undefined && bytesRead === 0) { |
| throw new FS.ErrnoError(ERRNO_CODES.EAGAIN); |
| } |
| 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(ERRNO_CODES.EIO); |
| } |
| } |
| 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 (Module['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(Module['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(ERRNO_CODES.EIO); |
| 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(ERRNO_CODES.EIO); |
| } |
| 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(ERRNO_CODES.EIO); |
| } |
| 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.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(ERRNO_CODES.EBADF); |
| 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 -ERRNO_CODES.ENOTDIR; |
| } |
| 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; |
| HEAP32[(((buf)+(36))>>2)]=stat.size; |
| HEAP32[(((buf)+(40))>>2)]=4096; |
| HEAP32[(((buf)+(44))>>2)]=stat.blocks; |
| HEAP32[(((buf)+(48))>>2)]=(stat.atime.getTime() / 1000)|0; |
| HEAP32[(((buf)+(52))>>2)]=0; |
| HEAP32[(((buf)+(56))>>2)]=(stat.mtime.getTime() / 1000)|0; |
| HEAP32[(((buf)+(60))>>2)]=0; |
| HEAP32[(((buf)+(64))>>2)]=(stat.ctime.getTime() / 1000)|0; |
| HEAP32[(((buf)+(68))>>2)]=0; |
| HEAP32[(((buf)+(72))>>2)]=stat.ino; |
| 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 -ERRNO_CODES.EINVAL; |
| } |
| FS.mknod(path, mode, dev); |
| return 0; |
| },doReadlink:function (path, buf, bufsize) { |
| if (bufsize <= 0) return -ERRNO_CODES.EINVAL; |
| 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 -ERRNO_CODES.EINVAL; |
| } |
| var node; |
| var lookup = FS.lookupPath(path, { follow: true }); |
| node = lookup.node; |
| 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 -ERRNO_CODES.EACCES; |
| } |
| 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 = Pointer_stringify(SYSCALLS.get()); |
| return ret; |
| },getStreamFromFD:function () { |
| var stream = FS.getStream(SYSCALLS.get()); |
| if (!stream) throw new FS.ErrnoError(ERRNO_CODES.EBADF); |
| return stream; |
| },getSocketFromFD:function () { |
| var socket = SOCKFS.getSocket(SYSCALLS.get()); |
| if (!socket) throw new FS.ErrnoError(ERRNO_CODES.EBADF); |
| return socket; |
| },getSocketAddress:function (allowNull) { |
| var addrp = SYSCALLS.get(), addrlen = SYSCALLS.get(); |
| if (allowNull && addrp === 0) return null; |
| var info = __read_sockaddr(addrp, addrlen); |
| if (info.errno) throw new FS.ErrnoError(info.errno); |
| info.addr = DNS.lookup_addr(info.addr) || info.addr; |
| return info; |
| },get64:function () { |
| var low = SYSCALLS.get(), high = SYSCALLS.get(); |
| if (low >= 0) assert(high === 0); |
| else assert(high === -1); |
| return low; |
| },getZero:function () { |
| assert(SYSCALLS.get() === 0); |
| }};function ___syscall140(which, varargs) {SYSCALLS.varargs = varargs; |
| try { |
| // llseek |
| var stream = SYSCALLS.getStreamFromFD(), offset_high = SYSCALLS.get(), offset_low = SYSCALLS.get(), result = SYSCALLS.get(), whence = SYSCALLS.get(); |
| // NOTE: offset_high is unused - Emscripten's off_t is 32-bit |
| var offset = offset_low; |
| FS.llseek(stream, offset, whence); |
| HEAP32[((result)>>2)]=stream.position; |
| if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state |
| return 0; |
| } catch (e) { |
| if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); |
| return -e.errno; |
| } |
| } |
| |
| function ___syscall145(which, varargs) {SYSCALLS.varargs = varargs; |
| try { |
| // readv |
| var stream = SYSCALLS.getStreamFromFD(), iov = SYSCALLS.get(), iovcnt = SYSCALLS.get(); |
| return SYSCALLS.doReadv(stream, iov, iovcnt); |
| } catch (e) { |
| if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); |
| return -e.errno; |
| } |
| } |
| |
| function ___syscall146(which, varargs) {SYSCALLS.varargs = varargs; |
| try { |
| // writev |
| var stream = SYSCALLS.getStreamFromFD(), iov = SYSCALLS.get(), iovcnt = SYSCALLS.get(); |
| return SYSCALLS.doWritev(stream, iov, iovcnt); |
| } catch (e) { |
| if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); |
| return -e.errno; |
| } |
| } |
| |
| 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 pos = 0; |
| while (stream.getdents.length > 0 && pos + 268 <= count) { |
| var id; |
| var type; |
| var name = stream.getdents.pop(); |
| 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. |
| } |
| HEAP32[((dirp + pos)>>2)]=id; |
| HEAP32[(((dirp + pos)+(4))>>2)]=stream.position; |
| HEAP16[(((dirp + pos)+(8))>>1)]=268; |
| HEAP8[(((dirp + pos)+(10))>>0)]=type; |
| stringToUTF8(name, dirp + pos + 11, 256); |
| pos += 268; |
| } |
| 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 -ERRNO_CODES.EINVAL; |
| } |
| 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: { |
| var arg = SYSCALLS.get(); |
| var offset = 0; |
| // We're always unlocked. |
| HEAP16[(((arg)+(offset))>>1)]=2; |
| return 0; |
| } |
| case 13: |
| case 14: |
| case 13: |
| case 14: |
| return 0; // Pretend that the locking is successful. |
| case 16: |
| case 8: |
| return -ERRNO_CODES.EINVAL; // 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(ERRNO_CODES.EINVAL); |
| return -1; |
| default: { |
| return -ERRNO_CODES.EINVAL; |
| } |
| } |
| } 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 -ERRNO_CODES.ENOTTY; |
| return 0; |
| } |
| case 21510: |
| case 21511: |
| case 21512: |
| case 21506: |
| case 21507: |
| case 21508: { |
| if (!stream.tty) return -ERRNO_CODES.ENOTTY; |
| return 0; // no-op, not actually adjusting terminal settings |
| } |
| case 21519: { |
| if (!stream.tty) return -ERRNO_CODES.ENOTTY; |
| var argp = SYSCALLS.get(); |
| HEAP32[((argp)>>2)]=0; |
| return 0; |
| } |
| case 21520: { |
| if (!stream.tty) return -ERRNO_CODES.ENOTTY; |
| return -ERRNO_CODES.EINVAL; // 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 -ERRNO_CODES.ENOTTY; |
| 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 -ERRNO_CODES.ENOTTY; |
| return 0; |
| } |
| default: abort('bad ioctl syscall ' + op); |
| } |
| } catch (e) { |
| if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); |
| return -e.errno; |
| } |
| } |
| |
| function ___syscall6(which, varargs) {SYSCALLS.varargs = varargs; |
| try { |
| // close |
| var stream = SYSCALLS.getStreamFromFD(); |
| FS.close(stream); |
| return 0; |
| } catch (e) { |
| if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); |
| return -e.errno; |
| } |
| } |
| |
| function ___unlock() {} |
| |
| |
| function __exit(status) { |
| // void _exit(int status); |
| // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html |
| exit(status); |
| }function _exit(status) { |
| __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 = Pointer_stringify(name); |
| if (!ENV.hasOwnProperty(name)) return 0; |
| |
| if (_getenv.ret) _free(_getenv.ret); |
| _getenv.ret = allocateUTF8(ENV[name]); |
| return _getenv.ret; |
| } |
| |
| |
| |
| |
| function _emscripten_memcpy_big(dest, src, num) { |
| HEAPU8.set(HEAPU8.subarray(src, src+num), dest); |
| return dest; |
| } |
| |
| |
| |
| |
| |
| |
| |
| FS.staticInit();__ATINIT__.unshift(function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() });__ATMAIN__.push(function() { FS.ignorePermissions = false });__ATEXIT__.push(function() { FS.quit() });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;; |
| __ATINIT__.unshift(function() { TTY.init() });__ATEXIT__.push(function() { TTY.shutdown() });; |
| if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); var NODEJS_PATH = require("path"); NODEFS.staticInit(); }; |
| DYNAMICTOP_PTR = staticAlloc(4); |
| |
| STACK_BASE = STACKTOP = alignMemory(STATICTOP); |
| |
| STACK_MAX = STACK_BASE + TOTAL_STACK; |
| |
| DYNAMIC_BASE = alignMemory(STACK_MAX); |
| |
| HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE; |
| |
| staticSealed = true; // seal the static portion of memory |
| |
| assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack"); |
| |
| 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(''); |
| } |
| |
| |
| |
| function nullFunc_ii(x) { err("Invalid function pointer called with signature 'ii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)"); err("Build with ASSERTIONS=2 for more info.");abort(x) } |
| |
| function nullFunc_iii(x) { err("Invalid function pointer called with signature 'iii'. 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)"); err("Build with ASSERTIONS=2 for more info.");abort(x) } |
| |
| function nullFunc_iiii(x) { err("Invalid function pointer called with signature 'iiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)"); err("Build with ASSERTIONS=2 for more info.");abort(x) } |
| |
| function nullFunc_vi(x) { err("Invalid function pointer called with signature 'vi'. 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)"); err("Build with ASSERTIONS=2 for more info.");abort(x) } |
| |
| function nullFunc_vii(x) { err("Invalid function pointer called with signature 'vii'. 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)"); err("Build with ASSERTIONS=2 for more info.");abort(x) } |
| |
| Module['wasmTableSize'] = 76; |
| |
| Module['wasmMaxTableSize'] = 76; |
| |
| function jsCall_ii(index,a1) { |
| return functionPointers[index](a1); |
| } |
| |
| 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_vi(index,a1) { |
| functionPointers[index](a1); |
| } |
| |
| function jsCall_vii(index,a1,a2) { |
| functionPointers[index](a1,a2); |
| } |
| |
| Module.asmGlobalArg = {}; |
| |
| Module.asmLibraryArg = { "abort": abort, "assert": assert, "enlargeMemory": enlargeMemory, "getTotalMemory": getTotalMemory, "setTempRet0": setTempRet0, "getTempRet0": getTempRet0, "abortOnCannotGrowMemory": abortOnCannotGrowMemory, "abortStackOverflow": abortStackOverflow, "nullFunc_ii": nullFunc_ii, "nullFunc_iii": nullFunc_iii, "nullFunc_iiii": nullFunc_iiii, "nullFunc_vi": nullFunc_vi, "nullFunc_vii": nullFunc_vii, "jsCall_ii": jsCall_ii, "jsCall_iii": jsCall_iii, "jsCall_iiii": jsCall_iiii, "jsCall_vi": jsCall_vi, "jsCall_vii": jsCall_vii, "___buildEnvironment": ___buildEnvironment, "___lock": ___lock, "___setErrNo": ___setErrNo, "___syscall140": ___syscall140, "___syscall145": ___syscall145, "___syscall146": ___syscall146, "___syscall195": ___syscall195, "___syscall220": ___syscall220, "___syscall221": ___syscall221, "___syscall5": ___syscall5, "___syscall54": ___syscall54, "___syscall6": ___syscall6, "___unlock": ___unlock, "__exit": __exit, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_exit": _exit, "_getenv": _getenv, "DYNAMICTOP_PTR": DYNAMICTOP_PTR, "tempDoublePtr": tempDoublePtr, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX }; |
| // EMSCRIPTEN_START_ASM |
| var asm =Module["asm"]// EMSCRIPTEN_END_ASM |
| (Module.asmGlobalArg, Module.asmLibraryArg, buffer); |
| |
| var real____emscripten_environ_constructor = asm["___emscripten_environ_constructor"]; asm["___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 real____emscripten_environ_constructor.apply(null, arguments); |
| }; |
| |
| var real____errno_location = asm["___errno_location"]; asm["___errno_location"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real____errno_location.apply(null, arguments); |
| }; |
| |
| var real___get_environ = asm["__get_environ"]; asm["__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 real___get_environ.apply(null, arguments); |
| }; |
| |
| var real___lou_allocMem = asm["__lou_allocMem"]; asm["__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 real___lou_allocMem.apply(null, arguments); |
| }; |
| |
| var real___lou_backTranslateWithTracing = asm["__lou_backTranslateWithTracing"]; asm["__lou_backTranslateWithTracing"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real___lou_backTranslateWithTracing.apply(null, arguments); |
| }; |
| |
| var real___lou_charHash = asm["__lou_charHash"]; asm["__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 real___lou_charHash.apply(null, arguments); |
| }; |
| |
| var real___lou_defaultTableResolver = asm["__lou_defaultTableResolver"]; asm["__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 real___lou_defaultTableResolver.apply(null, arguments); |
| }; |
| |
| var real___lou_extParseChars = asm["__lou_extParseChars"]; asm["__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 real___lou_extParseChars.apply(null, arguments); |
| }; |
| |
| var real___lou_extParseDots = asm["__lou_extParseDots"]; asm["__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 real___lou_extParseDots.apply(null, arguments); |
| }; |
| |
| var real___lou_findOpcodeName = asm["__lou_findOpcodeName"]; asm["__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 real___lou_findOpcodeName.apply(null, arguments); |
| }; |
| |
| var real___lou_findOpcodeNumber = asm["__lou_findOpcodeNumber"]; asm["__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 real___lou_findOpcodeNumber.apply(null, arguments); |
| }; |
| |
| var real___lou_getALine = asm["__lou_getALine"]; asm["__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 real___lou_getALine.apply(null, arguments); |
| }; |
| |
| var real___lou_getCharFromDots = asm["__lou_getCharFromDots"]; asm["__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 real___lou_getCharFromDots.apply(null, arguments); |
| }; |
| |
| var real___lou_getDotsForChar = asm["__lou_getDotsForChar"]; asm["__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 real___lou_getDotsForChar.apply(null, arguments); |
| }; |
| |
| var real___lou_getLastTableList = asm["__lou_getLastTableList"]; asm["__lou_getLastTableList"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real___lou_getLastTableList.apply(null, arguments); |
| }; |
| |
| var real___lou_getTablePath = asm["__lou_getTablePath"]; asm["__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 real___lou_getTablePath.apply(null, arguments); |
| }; |
| |
| var real___lou_handlePassVariableAction = asm["__lou_handlePassVariableAction"]; asm["__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 real___lou_handlePassVariableAction.apply(null, arguments); |
| }; |
| |
| var real___lou_handlePassVariableTest = asm["__lou_handlePassVariableTest"]; asm["__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 real___lou_handlePassVariableTest.apply(null, arguments); |
| }; |
| |
| var real___lou_logMessage = asm["__lou_logMessage"]; asm["__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 real___lou_logMessage.apply(null, arguments); |
| }; |
| |
| var real___lou_logWidecharBuf = asm["__lou_logWidecharBuf"]; asm["__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 real___lou_logWidecharBuf.apply(null, arguments); |
| }; |
| |
| var real___lou_outOfMemory = asm["__lou_outOfMemory"]; asm["__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 real___lou_outOfMemory.apply(null, arguments); |
| }; |
| |
| var real___lou_pattern_check = asm["__lou_pattern_check"]; asm["__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 real___lou_pattern_check.apply(null, arguments); |
| }; |
| |
| var real___lou_pattern_compile = asm["__lou_pattern_compile"]; asm["__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 real___lou_pattern_compile.apply(null, arguments); |
| }; |
| |
| var real___lou_pattern_reverse = asm["__lou_pattern_reverse"]; asm["__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 real___lou_pattern_reverse.apply(null, arguments); |
| }; |
| |
| var real___lou_resetPassVariables = asm["__lou_resetPassVariables"]; asm["__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 real___lou_resetPassVariables.apply(null, arguments); |
| }; |
| |
| var real___lou_resolveTable = asm["__lou_resolveTable"]; asm["__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 real___lou_resolveTable.apply(null, arguments); |
| }; |
| |
| var real___lou_showAttributes = asm["__lou_showAttributes"]; asm["__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 real___lou_showAttributes.apply(null, arguments); |
| }; |
| |
| var real___lou_showDots = asm["__lou_showDots"]; asm["__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 real___lou_showDots.apply(null, arguments); |
| }; |
| |
| var real___lou_showString = asm["__lou_showString"]; asm["__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 real___lou_showString.apply(null, arguments); |
| }; |
| |
| var real___lou_stringHash = asm["__lou_stringHash"]; asm["__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 real___lou_stringHash.apply(null, arguments); |
| }; |
| |
| var real___lou_translateWithTracing = asm["__lou_translateWithTracing"]; asm["__lou_translateWithTracing"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real___lou_translateWithTracing.apply(null, arguments); |
| }; |
| |
| var real__fflush = asm["_fflush"]; asm["_fflush"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real__fflush.apply(null, arguments); |
| }; |
| |
| var real__free = asm["_free"]; asm["_free"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real__free.apply(null, arguments); |
| }; |
| |
| var real__llvm_bswap_i32 = asm["_llvm_bswap_i32"]; asm["_llvm_bswap_i32"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real__llvm_bswap_i32.apply(null, arguments); |
| }; |
| |
| var real__lou_backTranslate = asm["_lou_backTranslate"]; asm["_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 real__lou_backTranslate.apply(null, arguments); |
| }; |
| |
| var real__lou_backTranslateString = asm["_lou_backTranslateString"]; asm["_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 real__lou_backTranslateString.apply(null, arguments); |
| }; |
| |
| var real__lou_charSize = asm["_lou_charSize"]; asm["_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 real__lou_charSize.apply(null, arguments); |
| }; |
| |
| var real__lou_charToDots = asm["_lou_charToDots"]; asm["_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 real__lou_charToDots.apply(null, arguments); |
| }; |
| |
| var real__lou_checkTable = asm["_lou_checkTable"]; asm["_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 real__lou_checkTable.apply(null, arguments); |
| }; |
| |
| var real__lou_compileString = asm["_lou_compileString"]; asm["_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 real__lou_compileString.apply(null, arguments); |
| }; |
| |
| var real__lou_dotsToChar = asm["_lou_dotsToChar"]; asm["_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 real__lou_dotsToChar.apply(null, arguments); |
| }; |
| |
| var real__lou_findTable = asm["_lou_findTable"]; asm["_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 real__lou_findTable.apply(null, arguments); |
| }; |
| |
| var real__lou_findTables = asm["_lou_findTables"]; asm["_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 real__lou_findTables.apply(null, arguments); |
| }; |
| |
| var real__lou_free = asm["_lou_free"]; asm["_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 real__lou_free.apply(null, arguments); |
| }; |
| |
| var real__lou_getDataPath = asm["_lou_getDataPath"]; asm["_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 real__lou_getDataPath.apply(null, arguments); |
| }; |
| |
| var real__lou_getEmphClasses = asm["_lou_getEmphClasses"]; asm["_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 real__lou_getEmphClasses.apply(null, arguments); |
| }; |
| |
| var real__lou_getTable = asm["_lou_getTable"]; asm["_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 real__lou_getTable.apply(null, arguments); |
| }; |
| |
| var real__lou_getTableInfo = asm["_lou_getTableInfo"]; asm["_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 real__lou_getTableInfo.apply(null, arguments); |
| }; |
| |
| var real__lou_getTypeformForEmphClass = asm["_lou_getTypeformForEmphClass"]; asm["_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 real__lou_getTypeformForEmphClass.apply(null, arguments); |
| }; |
| |
| var real__lou_hyphenate = asm["_lou_hyphenate"]; asm["_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 real__lou_hyphenate.apply(null, arguments); |
| }; |
| |
| var real__lou_indexTables = asm["_lou_indexTables"]; asm["_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 real__lou_indexTables.apply(null, arguments); |
| }; |
| |
| var real__lou_listTables = asm["_lou_listTables"]; asm["_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 real__lou_listTables.apply(null, arguments); |
| }; |
| |
| var real__lou_logEnd = asm["_lou_logEnd"]; asm["_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 real__lou_logEnd.apply(null, arguments); |
| }; |
| |
| var real__lou_logFile = asm["_lou_logFile"]; asm["_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 real__lou_logFile.apply(null, arguments); |
| }; |
| |
| var real__lou_logPrint = asm["_lou_logPrint"]; asm["_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 real__lou_logPrint.apply(null, arguments); |
| }; |
| |
| var real__lou_readCharFromFile = asm["_lou_readCharFromFile"]; asm["_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 real__lou_readCharFromFile.apply(null, arguments); |
| }; |
| |
| var real__lou_registerLogCallback = asm["_lou_registerLogCallback"]; asm["_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 real__lou_registerLogCallback.apply(null, arguments); |
| }; |
| |
| var real__lou_registerTableResolver = asm["_lou_registerTableResolver"]; asm["_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 real__lou_registerTableResolver.apply(null, arguments); |
| }; |
| |
| var real__lou_setDataPath = asm["_lou_setDataPath"]; asm["_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 real__lou_setDataPath.apply(null, arguments); |
| }; |
| |
| var real__lou_setLogLevel = asm["_lou_setLogLevel"]; asm["_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 real__lou_setLogLevel.apply(null, arguments); |
| }; |
| |
| var real__lou_translate = asm["_lou_translate"]; asm["_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 real__lou_translate.apply(null, arguments); |
| }; |
| |
| var real__lou_translatePrehyphenated = asm["_lou_translatePrehyphenated"]; asm["_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 real__lou_translatePrehyphenated.apply(null, arguments); |
| }; |
| |
| var real__lou_translateString = asm["_lou_translateString"]; asm["_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 real__lou_translateString.apply(null, arguments); |
| }; |
| |
| var real__lou_version = asm["_lou_version"]; asm["_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 real__lou_version.apply(null, arguments); |
| }; |
| |
| var real__malloc = asm["_malloc"]; asm["_malloc"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real__malloc.apply(null, arguments); |
| }; |
| |
| var real__memmove = asm["_memmove"]; asm["_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 real__memmove.apply(null, arguments); |
| }; |
| |
| var real__sbrk = asm["_sbrk"]; asm["_sbrk"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real__sbrk.apply(null, arguments); |
| }; |
| |
| var real_establishStackSpace = asm["establishStackSpace"]; asm["establishStackSpace"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real_establishStackSpace.apply(null, arguments); |
| }; |
| |
| var real_setThrew = asm["setThrew"]; asm["setThrew"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real_setThrew.apply(null, arguments); |
| }; |
| |
| var real_stackAlloc = asm["stackAlloc"]; asm["stackAlloc"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real_stackAlloc.apply(null, arguments); |
| }; |
| |
| var real_stackRestore = asm["stackRestore"]; asm["stackRestore"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real_stackRestore.apply(null, arguments); |
| }; |
| |
| var real_stackSave = asm["stackSave"]; asm["stackSave"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return real_stackSave.apply(null, arguments); |
| }; |
| Module["asm"] = asm; |
| var ___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_backTranslateWithTracing = Module["__lou_backTranslateWithTracing"] = 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_backTranslateWithTracing"].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_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_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_getLastTableList = Module["__lou_getLastTableList"] = 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_getLastTableList"].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_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_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_translateWithTracing = Module["__lou_translateWithTracing"] = 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_translateWithTracing"].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 _llvm_bswap_i32 = Module["_llvm_bswap_i32"] = 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"]["_llvm_bswap_i32"].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 _sbrk = Module["_sbrk"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["_sbrk"].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 runPostSets = Module["runPostSets"] = 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"]["runPostSets"].apply(null, arguments) }; |
| var setThrew = Module["setThrew"] = function() { |
| assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); |
| assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); |
| return Module["asm"]["setThrew"].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_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_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; |
| Module["Pointer_stringify"] = Pointer_stringify; |
| if (!Module["AsciiToString"]) Module["AsciiToString"] = function() { abort("'AsciiToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["stringToAscii"]) Module["stringToAscii"] = function() { abort("'stringToAscii' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["UTF8ArrayToString"]) Module["UTF8ArrayToString"] = function() { abort("'UTF8ArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["UTF8ToString"]) Module["UTF8ToString"] = function() { abort("'UTF8ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["stringToUTF8Array"]) Module["stringToUTF8Array"] = function() { abort("'stringToUTF8Array' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["stringToUTF8"]) Module["stringToUTF8"] = function() { abort("'stringToUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!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 (!Module["lengthBytesUTF16"]) Module["lengthBytesUTF16"] = function() { abort("'lengthBytesUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["UTF32ToString"]) Module["UTF32ToString"] = function() { abort("'UTF32ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["stringToUTF32"]) Module["stringToUTF32"] = function() { abort("'stringToUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["lengthBytesUTF32"]) Module["lengthBytesUTF32"] = function() { abort("'lengthBytesUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["allocateUTF8"]) Module["allocateUTF8"] = function() { abort("'allocateUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["stackTrace"]) Module["stackTrace"] = function() { abort("'stackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["addOnPreRun"]) Module["addOnPreRun"] = function() { abort("'addOnPreRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["addOnInit"]) Module["addOnInit"] = function() { abort("'addOnInit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["addOnPreMain"]) Module["addOnPreMain"] = function() { abort("'addOnPreMain' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["addOnExit"]) Module["addOnExit"] = function() { abort("'addOnExit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["addOnPostRun"]) Module["addOnPostRun"] = function() { abort("'addOnPostRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["writeStringToMemory"]) Module["writeStringToMemory"] = function() { abort("'writeStringToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["writeArrayToMemory"]) Module["writeArrayToMemory"] = function() { abort("'writeArrayToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!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 (!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 (!Module["GL"]) Module["GL"] = function() { abort("'GL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["staticAlloc"]) Module["staticAlloc"] = function() { abort("'staticAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["dynamicAlloc"]) Module["dynamicAlloc"] = function() { abort("'dynamicAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["warnOnce"]) Module["warnOnce"] = function() { abort("'warnOnce' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["loadDynamicLibrary"]) Module["loadDynamicLibrary"] = function() { abort("'loadDynamicLibrary' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["loadWebAssemblyModule"]) Module["loadWebAssemblyModule"] = function() { abort("'loadWebAssemblyModule' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["getLEB"]) Module["getLEB"] = function() { abort("'getLEB' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["getFunctionTables"]) Module["getFunctionTables"] = function() { abort("'getFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["alignFunctionTables"]) Module["alignFunctionTables"] = function() { abort("'alignFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["registerFunctions"]) Module["registerFunctions"] = function() { abort("'registerFunctions' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["addFunction"]) Module["addFunction"] = function() { abort("'addFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["removeFunction"]) Module["removeFunction"] = function() { abort("'removeFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["getFuncWrapper"]) Module["getFuncWrapper"] = function() { abort("'getFuncWrapper' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["prettyPrint"]) Module["prettyPrint"] = function() { abort("'prettyPrint' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["makeBigInt"]) Module["makeBigInt"] = function() { abort("'makeBigInt' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["dynCall"]) Module["dynCall"] = function() { abort("'dynCall' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["getCompilerSetting"]) Module["getCompilerSetting"] = function() { abort("'getCompilerSetting' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["stackSave"]) Module["stackSave"] = function() { abort("'stackSave' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["stackRestore"]) Module["stackRestore"] = function() { abort("'stackRestore' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["stackAlloc"]) Module["stackAlloc"] = function() { abort("'stackAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["establishStackSpace"]) Module["establishStackSpace"] = function() { abort("'establishStackSpace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["print"]) Module["print"] = function() { abort("'print' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; |
| if (!Module["printErr"]) Module["printErr"] = function() { abort("'printErr' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") };Module["ALLOC_NORMAL"] = ALLOC_NORMAL; |
| if (!Module["ALLOC_STACK"]) Object.defineProperty(Module, "ALLOC_STACK", { get: function() { abort("'ALLOC_STACK' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") } }); |
| if (!Module["ALLOC_STATIC"]) Object.defineProperty(Module, "ALLOC_STATIC", { get: function() { abort("'ALLOC_STATIC' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") } }); |
| if (!Module["ALLOC_DYNAMIC"]) Object.defineProperty(Module, "ALLOC_DYNAMIC", { get: function() { abort("'ALLOC_DYNAMIC' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") } }); |
| if (!Module["ALLOC_NONE"]) Object.defineProperty(Module, "ALLOC_NONE", { get: function() { abort("'ALLOC_NONE' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") } }); |
| |
| |
| |
| // Modularize mode returns a function, which can be called to |
| // create instances. The instances provide a then() method, |
| // must like a Promise, that receives a callback. The callback |
| // is called when the module is ready to run, with the module |
| // as a parameter. (Like a Promise, it also returns the module |
| // so you can use the output of .then(..)). |
| Module['then'] = function(func) { |
| // We may already be ready to run code at this time. if |
| // so, just queue a call to the callback. |
| if (Module['calledRun']) { |
| func(Module); |
| } else { |
| // we are not ready to call then() yet. we must call it |
| // at the same time we would call onRuntimeInitialized. |
| var old = Module['onRuntimeInitialized']; |
| Module['onRuntimeInitialized'] = function() { |
| if (old) old(); |
| func(Module); |
| }; |
| } |
| return Module; |
| }; |
| |
| /** |
| * @constructor |
| * @extends {Error} |
| * @this {ExitStatus} |
| */ |
| function ExitStatus(status) { |
| this.name = "ExitStatus"; |
| this.message = "Program terminated with exit(" + status + ")"; |
| this.status = status; |
| }; |
| ExitStatus.prototype = new Error(); |
| ExitStatus.prototype.constructor = ExitStatus; |
| |
| var initialStackTop; |
| var calledMain = false; |
| |
| dependenciesFulfilled = function runCaller() { |
| // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false) |
| if (!Module['calledRun']) run(); |
| if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled |
| } |
| |
| |
| |
| |
| |
| /** @type {function(Array=)} */ |
| function run(args) { |
| args = args || Module['arguments']; |
| |
| if (runDependencies > 0) { |
| return; |
| } |
| |
| writeStackCookie(); |
| |
| preRun(); |
| |
| if (runDependencies > 0) return; // a preRun added a dependency, run will be called later |
| if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame |
| |
| function doRun() { |
| if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening |
| Module['calledRun'] = true; |
| |
| if (ABORT) return; |
| |
| ensureInitRuntime(); |
| |
| preMain(); |
| |
| if (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 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 |
| var hasFS = true; |
| if (hasFS) { |
| ['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 && Module['noExitRuntime'] && status === 0) { |
| return; |
| } |
| |
| if (Module['noExitRuntime']) { |
| // if exit() was called, we may warn the user if the runtime isn't actually being shut down |
| if (!implicit) { |
| err('exit(' + status + ') called, 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; |
| STACKTOP = initialStackTop; |
| |
| exitRuntime(); |
| |
| if (Module['onExit']) Module['onExit'](status); |
| } |
| |
| Module['quit'](status, new ExitStatus(status)); |
| } |
| |
| var abortDecorators = []; |
| |
| function abort(what) { |
| if (Module['onAbort']) { |
| Module['onAbort'](what); |
| } |
| |
| if (what !== undefined) { |
| out(what); |
| err(what); |
| what = JSON.stringify(what) |
| } else { |
| what = ''; |
| } |
| |
| ABORT = true; |
| EXITSTATUS = 1; |
| |
| var extra = ''; |
| var output = 'abort(' + what + ') at ' + stackTrace() + extra; |
| if (abortDecorators) { |
| abortDecorators.forEach(function(decorator) { |
| output = decorator(output, what); |
| }); |
| } |
| throw output; |
| } |
| Module['abort'] = abort; |
| |
| if (Module['preInit']) { |
| if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; |
| while (Module['preInit'].length > 0) { |
| Module['preInit'].pop()(); |
| } |
| } |
| |
| |
| Module["noExitRuntime"] = true; |
| |
| run(); |
| |
| |
| |
| |
| |
| // {{MODULE_ADDITIONS}} |
| |
| |
| |
| if(this) { |
| this.liblouisBuilds = this.liblouisBuilds || {}; |
| |
| var version; |
| try { |
| version = this.ccall('lou_version', 'string', [], []); |
| } catch(e) { |
| version = "unknown"; |
| } |
| |
| this.liblouisBuilds[version] = this.liblouisBuilds[version] || []; |
| this.liblouisBuilds[version].push(Module); |
| } |
| |
| |
| |
| 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; |
| |