Lines Matching refs:FS
67 var nodeFS = require('fs');
1771 var path = (i >= 0) ? arguments[i] : FS.cwd();
1823 // // currently, FS.init does not distinguish if process.stdin is a file or TTY
1826 // // with text files until FS.init can be refactored.
1841 FS.registerDevice(dev, TTY.stream_ops);
1845 throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
1856 throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
1864 throw new FS.ErrnoError(ERRNO_CODES.EIO);
1867 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
1879 throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
1885 throw new FS.ErrnoError(ERRNO_CODES.EIO);
1942 if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
1944 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
1990 stream: FS.chrdev_stream_ops
1994 var node = FS.createNode(parent, name, mode, dev);
1995 if (FS.isDir(node.mode)) {
1999 } else if (FS.isFile(node.mode)) {
2004 } else if (FS.isLink(node.mode)) {
2007 } else if (FS.isChrdev(node.mode)) {
2026 attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
2033 if (FS.isDir(node.mode)) {
2035 } else if (FS.isFile(node.mode)) {
2037 } else if (FS.isLink(node.mode)) {
2064 throw FS.genericErrors[ERRNO_CODES.ENOENT];
2069 if (FS.isDir(old_node.mode)) {
2072 new_node = FS.lookupNode(new_dir, new_name);
2077 throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
2089 var node = FS.lookupNode(parent, name);
2091 throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
2108 if (!FS.isLink(node.mode)) {
2109 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2154 if (FS.isFile(stream.node.mode)) {
2159 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2170 if (!FS.isFile(stream.node.mode)) {
2171 throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
2195 throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
2269 var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
2276 stat = FS.stat(path);
2281 if (FS.isDir(stat.mode)) {
2282 check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
2317 var lookup = FS.lookupPath(path);
2319 stat = FS.stat(path);
2324 if (FS.isDir(stat.mode)) {
2326 } else if (FS.isFile(stat.mode)) {
2333 if (FS.isDir(entry.mode)) {
2334 FS.mkdir(path, entry.mode);
2335 } else if (FS.isFile(entry.mode)) {
2336 FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true });
2341 FS.utime(path, entry.timestamp, entry.timestamp);
2349 var lookup = FS.lookupPath(path);
2350 var stat = FS.stat(path);
2352 if (FS.isDir(stat.mode)) {
2353 FS.rmdir(path);
2354 } else if (FS.isFile(stat.mode)) {
2355 FS.unlink(path);
2455 if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
2456 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2458 var node = FS.createNode(parent, name, mode);
2465 stat = fs.lstatSync(path);
2473 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2495 stat = fs.lstatSync(path);
2498 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2527 fs.chmodSync(path, attr.mode);
2533 fs.utimesSync(path, date, date);
2536 fs.truncateSync(path, attr.size);
2540 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2548 // create the backing node for this in the fs root as well
2551 if (FS.isDir(node.mode)) {
2552 fs.mkdirSync(path, node.mode);
2554 fs.writeFileSync(path, '', { mode: node.mode });
2558 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2565 fs.renameSync(oldPath, newPath);
2568 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2573 fs.unlinkSync(path);
2576 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2581 fs.rmdirSync(path);
2584 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2589 return fs.readdirSync(path);
2592 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2597 fs.symlinkSync(oldPath, newPath);
2600 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2605 return fs.readlinkSync(path);
2608 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2613 if (FS.isFile(stream.node.mode)) {
2614 stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
2618 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2622 if (FS.isFile(stream.node.mode) && stream.nfd) {
2623 fs.closeSync(stream.nfd);
2627 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2634 res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
2636 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2649 res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
2651 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2659 if (FS.isFile(stream.node.mode)) {
2661 var stat = fs.fstatSync(stream.nfd);
2664 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2670 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2687 }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
2688 if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
2691 path = PATH.resolve(FS.cwd(), path);
2705 throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
2714 var current = FS.root;
2724 current = FS.lookupNode(current, parts[i]);
2728 if (FS.isMountpoint(current)) {
2738 while (FS.isLink(current.mode)) {
2739 var link = FS.readlink(current_path);
2742 var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
2746 throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
2756 if (FS.isRoot(node)) {
2771 return ((parentid + hash) >>> 0) % FS.nameTable.length;
2773 var hash = FS.hashName(node.parent.id, node.name);
2774 node.name_next = FS.nameTable[hash];
2775 FS.nameTable[hash] = node;
2777 var hash = FS.hashName(node.parent.id, node.name);
2778 if (FS.nameTable[hash] === node) {
2779 FS.nameTable[hash] = node.name_next;
2781 var current = FS.nameTable[hash];
2791 var err = FS.mayLookup(parent);
2793 throw new FS.ErrnoError(err);
2795 var hash = FS.hashName(parent.id, name);
2796 for (var node = FS.nameTable[hash]; node; node = node.name_next) {
2803 return FS.lookup(parent, name);
2805 if (!FS.FSNode) {
2806 FS.FSNode = function(parent, name, mode, rdev) {
2813 this.id = FS.nextInode++;
2821 FS.FSNode.prototype = {};
2829 Object.defineProperties(FS.FSNode.prototype, {
2839 get: function() { return FS.isDir(this.mode); },
2842 get: function() { return FS.isChrdev(this.mode); },
2847 var node = new FS.FSNode(parent, name, mode, rdev);
2849 FS.hashAddNode(node);
2853 FS.hashRemoveNode(node);
2873 var flags = FS.flagModes[str];
2886 if (FS.ignorePermissions) {
2899 return FS.nodePermissions(dir, 'x');
2902 var node = FS.lookupNode(dir, name);
2906 return FS.nodePermissions(dir, 'wx');
2910 node = FS.lookupNode(dir, name);
2914 var err = FS.nodePermissions(dir, 'wx');
2919 if (!FS.isDir(node.mode)) {
2922 if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
2926 if (FS.isDir(node.mode)) {
2935 if (FS.isLink(node.mode)) {
2937 } else if (FS.isDir(node.mode)) {
2943 return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
2946 fd_end = fd_end || FS.MAX_OPEN_FDS;
2948 if (!FS.streams[fd]) {
2952 throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
2954 return FS.streams[fd];
2956 if (!FS.FSStream) {
2957 FS.FSStream = function(){};
2958 FS.FSStream.prototype = {};
2960 Object.defineProperties(FS.FSStream.prototype, {
2978 stream.__proto__ = FS.FSStream.prototype;
2980 var newStream = new FS.FSStream();
2986 var fd = FS.nextfd(fd_start, fd_end);
2988 FS.streams[fd] = stream;
2991 FS.streams[fd] = null;
2993 return FS.streams[ptr - 1];
2997 var device = FS.getDevice(stream.node.rdev);
3005 throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
3013 FS.devices[dev] = { stream_ops: ops };
3015 return FS.devices[dev];
3035 var mounts = FS.getMounts(FS.root.mount);
3063 if (root && FS.root) {
3064 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
3066 var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
3071 if (FS.isMountpoint(node)) {
3072 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
3075 if (!FS.isDir(node.mode)) {
3076 throw new FS
3087 // create a root node for the fs
3093 FS.root = mountRoot;
3106 var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
3108 if (!FS.isMountpoint(lookup.node)) {
3109 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3115 var mounts = FS.getMounts(mount);
3117 Object.keys(FS.nameTable).forEach(function (hash) {
3118 var current = FS.nameTable[hash];
3124 FS.destroyNode(current);
3141 var lookup = FS.lookupPath(path, { parent: true });
3144 var err = FS.mayCreate(parent, name);
3146 throw new FS.ErrnoError(err);
3149 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
3156 return FS.mknod(path, mode, 0);
3161 return FS.mknod(path, mode, 0);
3168 return FS.mknod(path, mode, dev);
3170 var lookup = FS.lookupPath(newpath, { parent: true });
3173 var err = FS.mayCreate(parent, newname);
3175 throw new FS.ErrnoError(err);
3178 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
3189 lookup = FS.lookupPath(old_path, { parent: true });
3191 lookup = FS.lookupPath(new_path, { parent: true });
3194 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
3198 throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
3201 var old_node = FS.lookupNode(old_dir, old_name);
3205 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3210 throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
3215 new_node = FS.lookupNode(new_dir, new_name);
3224 var isdir = FS.isDir(old_node.mode);
3225 var err = FS.mayDelete(old_dir, old_name, isdir);
3227 throw new FS.ErrnoError(err);
3232 FS.mayDelete(new_dir, new_name, isdir) :
3233 FS.mayCreate(new_dir, new_name);
3235 throw new FS.ErrnoError(err);
3238 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
3240 if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
3241 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
3245 err = FS.nodePermissions(old_dir, 'w');
3247 throw new FS.ErrnoError(err);
3251 FS.hashRemoveNode(old_node);
3252 // do the underlying fs rename
3260 FS.hashAddNode(old_node);
3263 var lookup = FS.lookupPath(path, { parent: true });
3266 var node = FS.lookupNode(parent, name);
3267 var err = FS.mayDelete(parent, name, true);
3269 throw new FS.ErrnoError(err);
3272 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
3274 if (FS.isMountpoint(node)) {
3275 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
3278 FS.destroyNode(node);
3280 var lookup = FS.lookupPath(path, { follow: true });
3283 throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
3287 var lookup = FS.lookupPath(path, { parent: true });
3290 var node = FS.lookupNode(parent, name);
3291 var err = FS.mayDelete(parent, name, false);
3295 throw new FS.ErrnoError(err);
3298 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
3300 if (FS.isMountpoint(node)) {
3301 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
3304 FS.destroyNode(node);
3306 var lookup = FS.lookupPath(path);
3309 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3313 var lookup = FS.lookupPath(path, { follow: !dontFollow });
3316 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
3320 return FS.stat(path, true);
3324 var lookup = FS.lookupPath(path, { follow: !dontFollow });
3330 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
3337 FS.chmod(path, mode, true);
3339 var stream = FS.getStream(fd);
3341 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3343 FS.chmod(stream.node, mode);
3347 var lookup = FS.lookupPath(path, { follow: !dontFollow });
3353 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
3360 FS.chown(path, uid, gid, true);
3362 var stream = FS.getStream(fd);
3364 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3366 FS.chown(stream.node, uid, gid);
3369 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3373 var lookup = FS.lookupPath(path, { follow: true });
3379 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
3381 if (FS.isDir(node.mode)) {
3382 throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
3384 if (!FS.isFile(node.mode)) {
3385 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3387 var err = FS.nodePermissions(node, 'w');
3389 throw new FS.ErrnoError(err);
3396 var stream = FS.getStream(fd);
3398 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3401 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3403 FS.truncate(stream.node, len);
3405 var lookup = FS.lookupPath(path, { follow: true });
3411 flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
3424 var lookup = FS.lookupPath(path, {
3437 throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
3441 node = FS.mknod(path, mode, 0);
3445 throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
3448 if (FS.isChrdev(node.mode)) {
3452 var err = FS.mayOpen(node, flags);
3454 throw new FS.ErrnoError(err);
3458 FS.truncate(node, 0);
3464 var stream = FS.createStream({
3466 path: FS.getPath(node), // we want the absolute path to the node
3480 if (!FS.readFiles) FS.readFiles = {};
3481 if (!(path in FS.readFiles)) {
3482 FS.readFiles[path] = 1;
3495 FS.closeStream(stream.fd);
3499 throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
3504 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3507 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3509 if (FS.isDir(stream.node.mode)) {
3510 throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
3513 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3520 throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
3527 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3530 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3532 if (FS.isDir(stream.node.mode)) {
3533 throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
3536 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3543 throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
3547 FS.llseek(stream, 0, 2);
3554 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3557 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3559 if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
3560 throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
3563 throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
3569 throw new FS.ErrnoError(ERRNO_CODES.EACCES);
3572 throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
3577 throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
3588 var stream = FS.open(path, opts.flags);
3589 var stat = FS.stat(path);
3592 FS.read(stream, buf, 0, length, 0);
3602 FS.close(stream);
3611 var stream = FS.open(path, opts.flags, opts.mode);
3615 FS.write(stream, buf, 0, buf.length, 0, opts.canOwn);
3617 FS.write(stream, data, 0, data.length, 0, opts.canOwn);
3619 FS.close(stream);
3621 return FS.currentPath;
3623 var lookup = FS.lookupPath(path, { follow: true });
3624 if (!FS.isDir(lookup.node.mode)) {
3625 throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
3627 var err = FS.nodePermissions(lookup.node, 'x');
3629 throw new FS.ErrnoError(err);
3631 FS.currentPath = lookup.path;
3633 FS.mkdir('/tmp');
3636 FS.mkdir('/dev');
3638 FS.registerDevice(FS.makedev(1, 3), {
3642 FS.mkdev('/dev/null', FS.makedev(1, 3));
3646 TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
3647 TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
3648 FS.mkdev('/dev/tty', FS.makedev(5, 0));
3649 FS.mkdev('/dev/tty1', FS.makedev(6, 0));
3652 FS.mkdir('/dev/shm');
3653 FS.mkdir('/dev/shm/tmp');
3656 // input / output callback and that utilizes FS.createDevice
3664 FS.createDevice('/dev', 'stdin', Module['stdin']);
3666 FS.symlink('/dev/tty', '/dev/stdin');
3669 FS.createDevice('/dev', 'stdout', null, Module['stdout']);
3671 FS.symlink('/dev/tty', '/dev/stdout');
3674 FS.createDevice('/dev', 'stderr', null, Module['stderr']);
3676 FS.symlink('/dev/tty1', '/dev/stderr');
3680 var stdin = FS.open('/dev/stdin', 'r');
3681 HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
3684 var stdout = FS.open('/dev/stdout', 'w');
3685 HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
3688 var stderr = FS.open('/dev/stderr', 'w');
3689 HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
3692 if (FS.ErrnoError) return;
3693 FS.ErrnoError = function ErrnoError(errno) {
3703 FS.ErrnoError.prototype = new Error();
3704 FS.ErrnoError.prototype.constructor = FS.ErrnoError;
3707 FS.genericErrors[code] = new FS.ErrnoError(code);
3708 FS.genericErrors[code].stack = '<generic error, no stack>';
3711 FS.ensureErrnoError();
3713 FS.nameTable = new Array(4096);
3715 FS.mount(MEMFS, {}, '/');
3717 FS.createDefaultDirectories();
3718 FS.createDefaultDevices();
3720 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)');
3721 FS.init.initialized = true;
3723 FS.ensureErrnoError();
3730 FS.createStandardStreams();
3732 FS.init.initialized = false;
3733 for (var i = 0; i < FS.streams.length; i++) {
3734 var stream = FS.streams[i];
3738 FS.close(stream);
3754 var ret = FS.analyzePath(path, dontResolveLastLink);
3764 var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
3773 var lookup = FS.lookupPath(path, { parent: true });
3778 lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
3789 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
3790 var mode = FS.getMode(canRead, canWrite);
3791 return FS.mkdir(path, mode);
3793 parent = typeof parent === 'string' ? parent : FS.getPath(parent);
3800 FS.mkdir(current);
3808 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
3809 var mode = FS.getMode(canRead, canWrite);
3810 return FS.create(path, mode);
3812 var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
3813 var mode = FS.getMode(canRead, canWrite);
3814 var node = FS.create(path, mode);
3822 FS.chmod(node, mode | 146);
3823 var stream = FS.open(node, 'w');
3824 FS.write(stream, data, 0, data.length, 0, canOwn);
3825 FS.close(stream);
3826 FS.chmod(node, mode);
3830 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
3831 var mode = FS.getMode(!!input, !!output);
3832 if (!FS.createDevice.major) FS.createDevice.major = 64;
3833 var dev = FS.makedev(FS.createDevice.major++, 0);
3836 FS.registerDevice(dev, {
3853 throw new FS.ErrnoError(ERRNO_CODES.EIO);
3856 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
3872 throw new FS.ErrnoError(ERRNO_CODES.EIO);
3881 return FS.mkdev(path, mode, dev);
3883 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
3884 return FS.symlink(target, path);
3999 var node = FS.createFile(parent, name, properties, canRead, canWrite);
4015 if (!FS.forceLoadFile(node)) {
4016 throw new FS.ErrnoError(ERRNO_CODES.EIO);
4023 if (!FS.forceLoadFile(node)) {
4024 throw new FS.ErrnoError(ERRNO_CODES.EIO);
4052 FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
4085 var indexedDB = FS.indexedDB();
4087 var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
4094 db.createObjectStore(FS.DB_STORE_NAME);
4098 var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
4099 var files = transaction.objectStore(FS.DB_STORE_NAME);
4105 var putRequest = files.put(FS.analyzePath(path).object.contents, path);
4115 var indexedDB = FS.indexedDB();
4117 var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
4125 var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
4130 var files = transaction.objectStore(FS.DB_STORE_NAME);
4138 if (FS.analyzePath(path).exists) {
4139 FS.unlink(path);
4141 FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
4156 return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
4177 var node = FS.createNode(SOCKFS.root, name, 49152, 0);
4182 var stream = FS.createStream({
4185 flags: FS.modeStringToFlags('r+'),
4196 var stream = FS.getStream(fd);
4197 if (!stream || !FS.isSocket(stream.node.mode)) {
4294 throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
4448 throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
4466 if (!(e instanceof FS.ErrnoError)) throw e;
4472 throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
4484 throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
4486 throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
4498 throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
4501 throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
4504 throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
4540 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
4549 throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
4570 throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
4584 throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
4586 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
4619 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
4625 throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
4635 throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
4643 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
4646 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
4684 var stream = FS.getStream(fildes);
4691 return FS.write(stream, slab, buf, nbyte, offset);
4693 FS.handleFSError(e);
4699 var stream = FS.getStream(fildes);
4708 return FS.write(stream, slab, buf, nbyte);
4710 FS.handleFSError(e);
4718 stream = FS.getStreamFromPtr(stream);
4729 var streamObj = FS.getStreamFromPtr(stream);
5170 var streamObj = FS.getStreamFromPtr(stream);
5771 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() } });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;
5773 if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
5774 __ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
