Removed USE_OLD_FS

1 files changed, 214 insertions, 1529 deletions

diff --git a/src/library.js b/src/library.js
index 60a600ee..201a63e0 100644
--- a/src/library.js
+++ b/src/library.js
@@ -28,714 +28,7 @@ LibraryManager.library = {
   stderr: 'allocate(1, "i32*", ALLOC_STATIC)',
   _impure_ptr: 'allocate(1, "i32*", ALLOC_STATIC)',
 
-  $FSCOM__deps: ['$FS'],
-  $FSCOM: {
-    // Makes sure a file's contents are loaded. Returns whether the file has
-    // been loaded successfully. No-op for files that have been loaded already.
-    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);
-        } catch (e) {
-          success = false;
-        }
-      } else {
-        throw new Error('Cannot load without read() or XMLHttpRequest.');
-      }
-      if (!success) ___setErrNo(ERRNO_CODES.EIO);
-      return success;
-    },
-    // Creates a file record for lazy-loading from a URL. XXX This requires a synchronous
-    // XHR, which is not possible in browsers except in a web worker! Use preloading,
-    // either --preload-file in emcc or FS.createPreloadedFile
-    createLazyFile: function(parent, name, url, canRead, canWrite) {
-      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';
-        // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
-        var LazyUint8Array = function() {
-          this.lengthKnown = false;
-          this.chunks = []; // Loaded chunks. Index is the chunk number
-        }
-        LazyUint8Array.prototype.get = function(idx) {
-          if (idx > this.length-1 || idx < 0) {
-            return undefined;
-          }
-          var chunkOffset = idx % this.chunkSize;
-          var chunkNum = Math.floor(idx / this.chunkSize);
-          return this.getter(chunkNum)[chunkOffset];
-        }
-        LazyUint8Array.prototype.setDataGetter = function(getter) {
-          this.getter = getter;
-        }
-        LazyUint8Array.prototype.cacheLength = function() {
-            // 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";
-#if SMALL_XHR_CHUNKS
-            var chunkSize = 1024; // Chunk size in bytes
-#else
-            var chunkSize = 1024*1024; // Chunk size in bytes
-#endif
-
-            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];
-            });
-
-            this._length = datalength;
-            this._chunkSize = chunkSize;
-            this.lengthKnown = true;
-        }
-
-        var lazyArray = new LazyUint8Array();
-        Object.defineProperty(lazyArray, "length", {
-            get: function() {
-                if(!this.lengthKnown) {
-                    this.cacheLength();
-                }
-                return this._length;
-            }
-        });
-        Object.defineProperty(lazyArray, "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);
-#if USE_OLD_FS == 0
-      // 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;
-      }
-      // 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 () {
-          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, buffer, offset, length, position) {
-        var contents = stream.node.contents;
-        var size = Math.min(contents.length - position, length);
-        if (contents.slice) { // normal array
-          for (var i = 0; i < size; i++) {
-            buffer[offset + i] = contents[position + i];
-          }
-        } else {
-          for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
-            buffer[offset + i] = contents.get(position + i);
-          }
-        }
-        return size;
-      };
-      node.stream_ops = stream_ops;
-#endif
-      return node;
-    },
-    // Preloads a file asynchronously. You can call this before run, for example in
-    // preRun. run will be delayed until this file arrives and is set up.
-    // If you call it after run(), you may want to pause the main loop until it
-    // completes, if so, you can use the onload parameter to be notified when
-    // that happens.
-    // In addition to normally creating the file, we also asynchronously preload
-    // the browser-friendly versions of it: For an image, we preload an Image
-    // element and for an audio, and Audio. These are necessary for SDL_Image
-    // and _Mixer to find the files in preloadedImages/Audios.
-    // You can also call this with a typed array instead of a url. It will then
-    // do preloading for the Image/Audio part, as if the typed array were the
-    // result of an XHR that you did manually.
-    createPreloadedFile__deps: ['$PATH'],
-    createPreloadedFile: function(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile) {
-      Browser.init();
-      var fullname = PATH.join(parent, name).substr(1);
-      function processData(byteArray) {
-        function finish(byteArray) {
-          if (!dontCreateFile) {
-            FS.createDataFile(parent, name, byteArray, canRead, canWrite);
-          }
-          if (onload) onload();
-          removeRunDependency('cp ' + fullname);
-        }
-        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('cp ' + fullname);
-            });
-            handled = true;
-          }
-        });
-        if (!handled) finish(byteArray);
-      }
-      addRunDependency('cp ' + fullname);
-      if (typeof url == 'string') {
-        Browser.asyncLoad(url, function(byteArray) {
-          processData(byteArray);
-        }, onerror);
-      } else {
-        processData(url);
-      }
-    }
-  },
-
-#if USE_OLD_FS
-  $FS__deps: ['$FSCOM', '$ERRNO_CODES', '__setErrNo', 'stdin', 'stdout', 'stderr', '_impure_ptr'],
-  $FS__postset: 'FS.staticInit();' +
-                '__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });' +
-                '__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });' +
-                '__ATEXIT__.push({ func: function() { FS.quit() } });' +
-                // export some names through closure
-                '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;',
-  $FS: {
-    // The path to the current folder.
-    currentPath: '/',
-    // The inode to assign to the next created object.
-    nextInode: 2,
-    // Currently opened file or directory streams. Padded with null so the zero
-    // index is unused, as the indices are used as pointers. This is not split
-    // into separate fileStreams and folderStreams lists because the pointers
-    // must be interchangeable, e.g. when used in fdopen().
-    // streams is kept as a dense array. It may contain |null| to fill in
-    // holes, however.
-    streams: [null],
-#if ASSERTIONS
-    checkStreams: function() {
-      for (var i in FS.streams) if (FS.streams.hasOwnProperty(i)) assert(i >= 0 && i < FS.streams.length); // no keys not in dense span
-      for (var i = 0; i < FS.streams.length; i++) assert(typeof FS.streams[i] == 'object'); // no non-null holes in dense span
-    },
-#endif
-    // Whether we are currently ignoring permissions. Useful when preparing the
-    // filesystem and creating files inside read-only folders.
-    // This is set to false when the runtime is initialized, allowing you
-    // to modify the filesystem freely before run() is called.
-    ignorePermissions: true,
-    createStream: function(stream, fd) {
-      if (typeof stream === 'undefined') {
-        stream = null;
-      }
-      if (!fd) {
-        if (stream && stream.socket) {
-          for (var i = 1; i < 64; i++) {
-            if (!FS.streams[i]) {
-              fd = i;
-              break;
-            }
-          }
-          assert(fd, 'ran out of low fds for sockets');
-        } else {
-          fd = Math.max(FS.streams.length, 64);
-          for (var i = FS.streams.length; i < fd; i++) {
-            FS.streams[i] = null; // Keep dense
-          }
-        }
-      }
-      // Close WebSocket first if we are about to replace the fd (i.e. dup2)
-      if (FS.streams[fd] && FS.streams[fd].socket && FS.streams[fd].socket.close) {
-        FS.streams[fd].socket.close();
-      }
-      if (stream) {
-        stream.fd = fd;
-      }
-      FS.streams[fd] = stream;
-      return stream;
-    },
-    closeStream: function(stream) {
-      FS.streams[stream.fd] = null;
-    },
-    getStream: function (fd) {
-      return FS.streams[fd];
-    },
-    joinPath: function(parts, forceRelative) {
-      var ret = parts[0];
-      for (var i = 1; i < parts.length; i++) {
-        if (ret[ret.length-1] != '/') ret += '/';
-        ret += parts[i];
-      }
-      if (forceRelative && ret[0] == '/') ret = ret.substr(1);
-      return ret;
-    },
-    // Converts any path to an absolute path. Resolves embedded "." and ".."
-    // parts.
-    absolutePath: function(relative, base) {
-      if (typeof relative !== 'string') return null;
-      if (base === undefined) base = FS.currentPath;
-      if (relative && relative[0] == '/') base = '';
-      var full = base + '/' + relative;
-      var parts = full.split('/').reverse();
-      var absolute = [''];
-      while (parts.length) {
-        var part = parts.pop();
-        if (part == '' || part == '.') {
-          // Nothing.
-        } else if (part == '..') {
-          if (absolute.length > 1) absolute.pop();
-        } else {
-          absolute.push(part);
-        }
-      }
-      return absolute.length == 1 ? '/' : absolute.join('/');
-    },
-    // Analyzes a relative or absolute path returning a description, containing:
-    //   isRoot: Whether the path points to the root.
-    //   exists: Whether the object at the path exists.
-    //   error: If !exists, this will contain the errno code of the cause.
-    //   name: The base name of the object (null if !parentExists).
-    //   path: The absolute path to the object, with all links resolved.
-    //   object: The filesystem record of the object referenced by the path.
-    //   parentExists: Whether the parent of the object exist and is a folder.
-    //   parentPath: The absolute path to the parent folder.
-    //   parentObject: The filesystem record of the parent folder.
-    analyzePath: function(path, dontResolveLastLink, linksVisited) {
-      var ret = {
-        isRoot: false,
-        exists: false,
-        error: 0,
-        name: null,
-        path: null,
-        object: null,
-        parentExists: false,
-        parentPath: null,
-        parentObject: null
-      };
-#if FS_LOG
-      var inputPath = path;
-      function log() {
-        Module['print']('FS.analyzePath("' + inputPath + '", ' +
-                                             dontResolveLastLink + ', ' +
-                                             linksVisited + ') => {' +
-                        'isRoot: ' + ret.isRoot + ', ' +
-                        'exists: ' + ret.exists + ', ' +
-                        'error: ' + ret.error + ', ' +
-                        'name: "' + ret.name + '", ' +
-                        'path: "' + ret.path + '", ' +
-                        'object: ' + ret.object + ', ' +
-                        'parentExists: ' + ret.parentExists + ', ' +
-                        'parentPath: "' + ret.parentPath + '", ' +
-                        'parentObject: ' + ret.parentObject + '}');
-      }
-#endif
-      path = FS.absolutePath(path);
-      if (path == '/') {
-        ret.isRoot = true;
-        ret.exists = ret.parentExists = true;
-        ret.name = '/';
-        ret.path = ret.parentPath = '/';
-        ret.object = ret.parentObject = FS.root;
-      } else if (path !== null) {
-        linksVisited = linksVisited || 0;
-        path = path.slice(1).split('/');
-        var current = FS.root;
-        var traversed = [''];
-        while (path.length) {
-          if (path.length == 1 && current.isFolder) {
-            ret.parentExists = true;
-            ret.parentPath = traversed.length == 1 ? '/' : traversed.join('/');
-            ret.parentObject = current;
-            ret.name = path[0];
-          }
-          var target = path.shift();
-          if (!current.isFolder) {
-            ret.error = ERRNO_CODES.ENOTDIR;
-            break;
-          } else if (!current.read) {
-            ret.error = ERRNO_CODES.EACCES;
-            break;
-          } else if (!current.contents.hasOwnProperty(target)) {
-            ret.error = ERRNO_CODES.ENOENT;
-            break;
-          }
-          current = current.contents[target];
-          if (current.link && !(dontResolveLastLink && path.length == 0)) {
-            if (linksVisited > 40) { // Usual Linux SYMLOOP_MAX.
-              ret.error = ERRNO_CODES.ELOOP;
-              break;
-            }
-            var link = FS.absolutePath(current.link, traversed.join('/'));
-            ret = FS.analyzePath([link].concat(path).join('/'),
-                                 dontResolveLastLink, linksVisited + 1);
-#if FS_LOG
-            log();
-#endif
-            return ret;
-          }
-          traversed.push(target);
-          if (path.length == 0) {
-            ret.exists = true;
-            ret.path = traversed.join('/');
-            ret.object = current;
-          }
-        }
-      }
-#if FS_LOG
-      log();
-#endif
-      return ret;
-    },
-    // Finds the file system object at a given path. If dontResolveLastLink is
-    // set to true and the object is a symbolic link, it will be returned as is
-    // instead of being resolved. Links embedded in the path are still resolved.
-    findObject: function(path, dontResolveLastLink) {
-      var ret = FS.analyzePath(path, dontResolveLastLink);
-      if (ret.exists) {
-        return ret.object;
-      } else {
-        ___setErrNo(ret.error);
-        return null;
-      }
-    },
-    // Creates a file system record: file, link, device or folder.
-    createObject: function(parent, name, properties, canRead, canWrite) {
-#if FS_LOG
-      Module['print']('FS.createObject("' + parent + '", ' +
-                                      '"' + name + '", ' +
-                                          JSON.stringify(properties) + ', ' +
-                                          canRead + ', ' +
-                                          canWrite + ')');
-#endif
-      if (!parent) parent = '/';
-      if (typeof parent === 'string') parent = FS.findObject(parent);
-
-      if (!parent) {
-        ___setErrNo(ERRNO_CODES.EACCES);
-        throw new Error('Parent path must exist.');
-      }
-      if (!parent.isFolder) {
-        ___setErrNo(ERRNO_CODES.ENOTDIR);
-        throw new Error('Parent must be a folder.');
-      }
-      if (!parent.write && !FS.ignorePermissions) {
-        ___setErrNo(ERRNO_CODES.EACCES);
-        throw new Error('Parent folder must be writeable.');
-      }
-      if (!name || name == '.' || name == '..') {
-        ___setErrNo(ERRNO_CODES.ENOENT);
-        throw new Error('Name must not be empty.');
-      }
-      if (parent.contents.hasOwnProperty(name)) {
-        ___setErrNo(ERRNO_CODES.EEXIST);
-        throw new Error("Can't overwrite object.");
-      }
-
-      parent.contents[name] = {
-        read: canRead === undefined ? true : canRead,
-        write: canWrite === undefined ? false : canWrite,
-        timestamp: Date.now(),
-        inodeNumber: FS.nextInode++
-      };
-      for (var key in properties) {
-        if (properties.hasOwnProperty(key)) {
-          parent.contents[name][key] = properties[key];
-        }
-      }
-
-      return parent.contents[name];
-    },
-    // Creates a folder.
-    createFolder: function(parent, name, canRead, canWrite) {
-      var properties = {isFolder: true, isDevice: false, contents: {}};
-      return FS.createObject(parent, name, properties, canRead, canWrite);
-    },
-    // Creates a folder and all its missing parents.
-    createPath: function(parent, path, canRead, canWrite) {
-      var current = FS.findObject(parent);
-      if (current === null) throw new Error('Invalid parent.');
-      path = path.split('/').reverse();
-      while (path.length) {
-        var part = path.pop();
-        if (!part) continue;
-        if (!current.contents.hasOwnProperty(part)) {
-          FS.createFolder(current, part, canRead, canWrite);
-        }
-        current = current.contents[part];
-      }
-      return current;
-    },
-
-    // Creates a file record, given specific properties.
-    createFile: function(parent, name, properties, canRead, canWrite) {
-      properties.isFolder = false;
-      return FS.createObject(parent, name, properties, canRead, canWrite);
-    },
-    // Creates a file record from existing data.
-    createDataFile: function(parent, name, data, canRead, canWrite) {
-      if (typeof data === 'string') {
-        var dataArray = new Array(data.length);
-        for (var i = 0, len = data.length; i < len; ++i) dataArray[i] = data.charCodeAt(i);
-        data = dataArray;
-      }
-      var properties = {
-        isDevice: false,
-        contents: data.subarray ? data.subarray(0) : data // as an optimization, create a new array wrapper (not buffer) here, to help JS engines understand this object
-      };
-      return FS.createFile(parent, name, properties, canRead, canWrite);
-    },
-    createLazyFile: function() {
-      return FSCOM.createLazyFile.apply(this, arguments);
-    },
-    createPreloadedFile: function() {
-      FSCOM.createPreloadedFile.apply(this, arguments);
-    },
-    // Creates a link to a specific local path.
-    createLink: function(parent, name, target, canRead, canWrite) {
-      var properties = {isDevice: false, link: target};
-      return FS.createFile(parent, name, properties, canRead, canWrite);
-    },
-    // Creates a character device with input and output callbacks:
-    //   input: Takes no parameters, returns a byte value or null if no data is
-    //          currently available.
-    //   output: Takes a byte value; doesn't return anything. Can also be passed
-    //           null to perform a flush of any cached data.
-    createDevice: function(parent, name, input, output) {
-      if (!(input || output)) {
-        throw new Error('A device must have at least one callback defined.');
-      }
-      var ops = {isDevice: true, input: input, output: output};
-      return FS.createFile(parent, name, ops, Boolean(input), Boolean(output));
-    },
-    forceLoadFile: function() {
-      return FSCOM.forceLoadFile.apply(this, arguments);
-    },
-    staticInit: function () {
-      // The main file system tree. All the contents are inside this.
-      FS.root = {
-        read: true,
-        write: true,
-        isFolder: true,
-        isDevice: false,
-        timestamp: Date.now(),
-        inodeNumber: 1,
-        contents: {}
-      };
-      // Create the temporary folder, if not already created
-      try {
-        FS.createFolder('/', 'tmp', true, true);
-      } catch(e) {}
-      FS.createFolder('/', 'dev', true, true);
-    },
-    // Initializes the filesystems with stdin/stdout/stderr devices, given
-    // optional handlers.
-    init: function(input, output, error) {
-      // Make sure we initialize only once.
-      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;
-
-      // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
-      input = input || Module['stdin'];
-      output = output || Module['stdout'];
-      error = error || Module['stderr'];
-
-      // Default handlers.
-      var stdinOverridden = true, stdoutOverridden = true, stderrOverridden = true;
-      if (!input) {
-        stdinOverridden = false;
-        input = function() {
-          if (!input.cache || !input.cache.length) {
-            var result;
-            if (typeof window != 'undefined' &&
-                typeof window.prompt == 'function') {
-              // Browser.
-              result = window.prompt('Input: ');
-              if (result === null) result = String.fromCharCode(0); // cancel ==> EOF
-            } else if (typeof readline == 'function') {
-              // Command line.
-              result = readline();
-            }
-            if (!result) result = '';
-            input.cache = intArrayFromString(result + '\n', true);
-          }
-          return input.cache.shift();
-        };
-      }
-      var utf8 = new Runtime.UTF8Processor();
-      function createSimpleOutput() {
-        var fn = function (val) {
-          if (val === null || val === {{{ charCode('\n') }}}) {
-            fn.printer(fn.buffer.join(''));
-            fn.buffer = [];
-          } else {
-            fn.buffer.push(utf8.processCChar(val));
-          }
-        };
-        return fn;
-      }
-      if (!output) {
-        stdoutOverridden = false;
-        output = createSimpleOutput();
-      }
-      if (!output.printer) output.printer = Module['print'];
-      if (!output.buffer) output.buffer = [];
-      if (!error) {
-        stderrOverridden = false;
-        error = createSimpleOutput();
-      }
-      if (!error.printer) error.printer = Module['printErr'];
-      if (!error.buffer) error.buffer = [];
-
-      // Create the I/O devices.
-      var stdin = FS.createDevice('/dev', 'stdin', input);
-      stdin.isTerminal = !stdinOverridden;
-      var stdout = FS.createDevice('/dev', 'stdout', null, output);
-      stdout.isTerminal = !stdoutOverridden;
-      var stderr = FS.createDevice('/dev', 'stderr', null, error);
-      stderr.isTerminal = !stderrOverridden;
-      FS.createDevice('/dev', 'tty', input, output);
-      FS.createDevice('/dev', 'null', function(){}, function(){});
-
-      // Create default streams.
-      FS.streams[1] = {
-        path: '/dev/stdin',
-        object: stdin,
-        position: 0,
-        isRead: true,
-        isWrite: false,
-        isAppend: false,
-        error: false,
-        eof: false,
-        ungotten: []
-      };
-      FS.streams[2] = {
-        path: '/dev/stdout',
-        object: stdout,
-        position: 0,
-        isRead: false,
-        isWrite: true,
-        isAppend: false,
-        error: false,
-        eof: false,
-        ungotten: []
-      };
-      FS.streams[3] = {
-        path: '/dev/stderr',
-        object: stderr,
-        position: 0,
-        isRead: false,
-        isWrite: true,
-        isAppend: false,
-        error: false,
-        eof: false,
-        ungotten: []
-      };
-      // TODO: put these low in memory like we used to assert on: assert(Math.max(_stdin, _stdout, _stderr) < 15000); // make sure these are low, we flatten arrays with these
-      {{{ makeSetValue(makeGlobalUse('_stdin'), 0, 1, 'void*') }}};
-      {{{ makeSetValue(makeGlobalUse('_stdout'), 0, 2, 'void*') }}};
-      {{{ makeSetValue(makeGlobalUse('_stderr'), 0, 3, 'void*') }}};
-
-      // Other system paths
-      FS.createPath('/', 'dev/shm/tmp', true, true); // temp files
-
-      // Newlib initialization
-      for (var i = FS.streams.length; i < Math.max(_stdin, _stdout, _stderr) + {{{ QUANTUM_SIZE }}}; i++) {
-        FS.streams[i] = null; // Make sure to keep FS.streams dense
-      }
-      FS.streams[_stdin] = FS.streams[1];
-      FS.streams[_stdout] = FS.streams[2];
-      FS.streams[_stderr] = FS.streams[3];
-#if ASSERTIONS
-      FS.checkStreams();
-      // see previous TODO on stdin etc.: assert(FS.streams.length < 1024); // at this early stage, we should not have a large set of file descriptors - just a few
-#endif
-      allocate([ allocate(
-        {{{ Runtime.QUANTUM_SIZE === 4 ? '[0, 0, 0, 0, _stdin, 0, 0, 0, _stdout, 0, 0, 0, _stderr, 0, 0, 0]' : '[0, _stdin, _stdout, _stderr]' }}},
-        'void*', ALLOC_NORMAL) ], 'void*', ALLOC_NONE, {{{ makeGlobalUse('__impure_ptr') }}});
-    },
-
-    quit: function() {
-      if (!FS.init.initialized) return;
-      // Flush any partially-printed lines in stdout and stderr. Careful, they may have been closed
-      if (FS.streams[2] && FS.streams[2].object.output.buffer.length > 0) FS.streams[2].object.output({{{ charCode('\n') }}});
-      if (FS.streams[3] && FS.streams[3].object.output.buffer.length > 0) FS.streams[3].object.output({{{ charCode('\n') }}});
-    },
-
-    // Standardizes a path. Useful for making comparisons of pathnames work in a consistent manner.
-    // For example, ./file and file are really the same, so this function will remove ./
-    standardizePath: function(path) {
-      if (path.substr(0, 2) == './') path = path.substr(2);
-      return path;
-    },
-
-    deleteFile: function(path) {
-      path = FS.analyzePath(path);
-      if (!path.parentExists || !path.exists) {
-        throw 'Invalid path ' + path;
-      }
-      delete path.parentObject.contents[path.name];
-    }
-  },
-#else
-  $FS__deps: ['$FSCOM', '$ERRNO_CODES', '$ERRNO_MESSAGES', '__setErrNo', '$VFS', '$PATH', '$TTY', '$MEMFS', 'stdin', 'stdout', 'stderr', 'fflush'],
+  $FS__deps: ['$ERRNO_CODES', '$ERRNO_MESSAGES', '__setErrNo', '$VFS', '$PATH', '$TTY', '$MEMFS', 'stdin', 'stdout', 'stderr', 'fflush'],
   $FS__postset: 'FS.staticInit();' +
                 '__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });' +
                 '__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });' +
@@ -1399,14 +692,216 @@ LibraryManager.library = {
       var path = PATH.join(typeof parent === 'string' ? parent : FS.getPath(parent), name);
       return VFS.symlink(target, path);
     },
-    forceLoadFile: function() {
-      return FSCOM.forceLoadFile.apply(this, arguments);
+    // Makes sure a file's contents are loaded. Returns whether the file has
+    // been loaded successfully. No-op for files that have been loaded already.
+    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);
+        } catch (e) {
+          success = false;
+        }
+      } else {
+        throw new Error('Cannot load without read() or XMLHttpRequest.');
+      }
+      if (!success) ___setErrNo(ERRNO_CODES.EIO);
+      return success;
     },
-    createLazyFile: function () {
-      return FSCOM.createLazyFile.apply(this, arguments);
+    // Creates a file record for lazy-loading from a URL. XXX This requires a synchronous
+    // XHR, which is not possible in browsers except in a web worker! Use preloading,
+    // either --preload-file in emcc or FS.createPreloadedFile
+    createLazyFile: function(parent, name, url, canRead, canWrite) {
+      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';
+        // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
+        var LazyUint8Array = function() {
+          this.lengthKnown = false;
+          this.chunks = []; // Loaded chunks. Index is the chunk number
+        }
+        LazyUint8Array.prototype.get = function(idx) {
+          if (idx > this.length-1 || idx < 0) {
+            return undefined;
+          }
+          var chunkOffset = idx % this.chunkSize;
+          var chunkNum = Math.floor(idx / this.chunkSize);
+          return this.getter(chunkNum)[chunkOffset];
+        }
+        LazyUint8Array.prototype.setDataGetter = function(getter) {
+          this.getter = getter;
+        }
+        LazyUint8Array.prototype.cacheLength = function() {
+            // 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";
+#if SMALL_XHR_CHUNKS
+            var chunkSize = 1024; // Chunk size in bytes
+#else
+            var chunkSize = 1024*1024; // Chunk size in bytes
+#endif
+
+            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];
+            });
+
+            this._length = datalength;
+            this._chunkSize = chunkSize;
+            this.lengthKnown = true;
+        }
+
+        var lazyArray = new LazyUint8Array();
+        Object.defineProperty(lazyArray, "length", {
+            get: function() {
+                if(!this.lengthKnown) {
+                    this.cacheLength();
+                }
+                return this._length;
+            }
+        });
+        Object.defineProperty(lazyArray, "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;
+      }
+      // 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 () {
+          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, buffer, offset, length, position) {
+        var contents = stream.node.contents;
+        var size = Math.min(contents.length - position, length);
+        if (contents.slice) { // normal array
+          for (var i = 0; i < size; i++) {
+            buffer[offset + i] = contents[position + i];
+          }
+        } else {
+          for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
+            buffer[offset + i] = contents.get(position + i);
+          }
+        }
+        return size;
+      };
+      node.stream_ops = stream_ops;
+      return node;
     },
-    createPreloadedFile: function () {
-      FSCOM.createPreloadedFile.apply(this, arguments);
+    // Preloads a file asynchronously. You can call this before run, for example in
+    // preRun. run will be delayed until this file arrives and is set up.
+    // If you call it after run(), you may want to pause the main loop unt