Lines Matching refs:fs
57 var nodeFS = require('fs');
1440 // // currently, FS.init does not distinguish if process.stdin is a file or TTY
1443 // // with text files until FS.init can be refactored.
1458 FS.registerDevice(dev, TTY.stream_ops);
1462 throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
1473 throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
1481 throw new FS.ErrnoError(ERRNO_CODES.EIO);
1484 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
1496 throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
1502 throw new FS.ErrnoError(ERRNO_CODES.EIO);
1559 if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
1561 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
1607 stream: FS.chrdev_stream_ops
1611 var node = FS.createNode(parent, name, mode, dev);
1612 if (FS.isDir(node.mode)) {
1616 } else if (FS.isFile(node.mode)) {
1621 } else if (FS.isLink(node.mode)) {
1624 } else if (FS.isChrdev(node.mode)) {
1643 attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
1650 if (FS.isDir(node.mode)) {
1652 } else if (FS.isFile(node.mode)) {
1654 } else if (FS.isLink(node.mode)) {
1681 throw FS.genericErrors[ERRNO_CODES.ENOENT];
1686 if (FS.isDir(old_node.mode)) {
1689 new_node = FS.lookupNode(new_dir, new_name);
1694 throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
1706 var node = FS.lookupNode(parent, name);
1708 throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
1725 if (!FS.isLink(node.mode)) {
1726 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
1771 if (FS.isFile(stream.node.mode)) {
1776 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
1787 if (!FS.isFile(stream.node.mode)) {
1788 throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
1812 throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
1886 var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
1893 stat = FS.stat(path);
1898 if (FS.isDir(stat.mode)) {
1899 check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
1934 var lookup = FS.lookupPath(path);
1936 stat = FS.stat(path);
1941 if (FS.isDir(stat.mode)) {
1943 } else if (FS.isFile(stat.mode)) {
1950 if (FS.isDir(entry.mode)) {
1951 FS.mkdir(path, entry.mode);
1952 } else if (FS.isFile(entry.mode)) {
1953 FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true });
1958 FS.utime(path, entry.timestamp, entry.timestamp);
1966 var lookup = FS.lookupPath(path);
1967 var stat = FS.stat(path);
1969 if (FS.isDir(stat.mode)) {
1970 FS.rmdir(path);
1971 } else if (FS.isFile(stat.mode)) {
1972 FS.unlink(path);
2072 if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
2073 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2075 var node = FS.createNode(parent, name, mode);
2082 stat = fs.lstatSync(path);
2090 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2112 stat = fs.lstatSync(path);
2115 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2144 fs.chmodSync(path, attr.mode);
2150 fs.utimesSync(path, date, date);
2153 fs.truncateSync(path, attr.size);
2157 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2165 // create the backing node for this in the fs root as well
2168 if (FS.isDir(node.mode)) {
2169 fs.mkdirSync(path, node.mode);
2171 fs.writeFileSync(path, '', { mode: node.mode });
2175 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2182 fs.renameSync(oldPath, newPath);
2185 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2190 fs.unlinkSync(path);
2193 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2198 fs.rmdirSync(path);
2201 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2206 return fs.readdirSync(path);
2209 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2214 fs.symlinkSync(oldPath, newPath);
2217 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2222 return fs.readlinkSync(path);
2225 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2230 if (FS.isFile(stream.node.mode)) {
2231 stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
2235 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2239 if (FS.isFile(stream.node.mode) && stream.nfd) {
2240 fs.closeSync(stream.nfd);
2244 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2251 res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
2253 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2266 res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
2268 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2276 if (FS.isFile(stream.node.mode)) {
2278 var stat = fs.fstatSync(stream.nfd);
2281 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2287 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2304 }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
2305 if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
2308 path = PATH.resolve(FS.cwd(), path);
2322 throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
2331 var current = FS.root;
2341 current = FS.lookupNode(current, parts[i]);
2345 if (FS.isMountpoint(current)) {
2355 while (FS.isLink(current.mode)) {
2356 var link = FS.readlink(current_path);
2359 var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
2363 throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
2373 if (FS.isRoot(node)) {
2388 return ((parentid + hash) >>> 0) % FS.nameTable.length;
2390 var hash = FS.hashName(node.parent.id, node.name);
2391 node.name_next = FS.nameTable[hash];
2392 FS.nameTable[hash] = node;
2394 var hash = FS.hashName(node.parent.id, node.name);
2395 if (FS.nameTable[hash] === node) {
2396 FS.nameTable[hash] = node.name_next;
2398 var current = FS.nameTable[hash];
2408 var err = FS.mayLookup(parent);
2410 throw new FS.ErrnoError(err);
2412 var hash = FS.hashName(parent.id, name);
2413 for (var node = FS.nameTable[hash]; node; node = node.name_next) {
2420 return FS.lookup(parent, name);
2422 if (!FS.FSNode) {
2423 FS.FSNode = function(parent, name, mode, rdev) {
2430 this.id = FS.nextInode++;
2438 FS.FSNode.prototype = {};
2446 Object.defineProperties(FS.FSNode.prototype, {
2456 get: function() { return FS.isDir(this.mode); },
2459 get: function() { return FS.isChrdev(this.mode); },
2464 var node = new FS.FSNode(parent, name, mode, rdev);
2466 FS.hashAddNode(node);
2470 FS.hashRemoveNode(node);
2490 var flags = FS.flagModes[str];
2503 if (FS.ignorePermissions) {
2516 return FS.nodePermissions(dir, 'x');
2519 var node = FS.lookupNode(dir, name);
2523 return FS.nodePermissions(dir, 'wx');
2527 node = FS.lookupNode(dir, name);
2531 var err = FS.nodePermissions(dir, 'wx');
2536 if (!FS.isDir(node.mode)) {
2539 if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
2543 if (FS.isDir(node.mode)) {
2552 if (FS.isLink(node.mode)) {
2554 } else if (FS.isDir(node.mode)) {
2560 return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
2563 fd_end = fd_end || FS.MAX_OPEN_FDS;
2565 if (!FS.streams[fd]) {
2569 throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
2571 return FS.streams[fd];
2573 if (!FS.FSStream) {
2574 FS.FSStream = function(){};
2575 FS.FSStream.prototype = {};
2577 Object.defineProperties(FS.FSStream.prototype, {
2595 stream.__proto__ = FS.FSStream.prototype;
2597 var newStream = new FS.FSStream();
2603 var fd = FS.nextfd(fd_start, fd_end);
2605 FS.streams[fd] = stream;
2608 FS.streams[fd] = null;
2610 return FS.streams[ptr - 1];
2614 var device = FS.getDevice(stream.node.rdev);
2622 throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
2630 FS.devices[dev] = { stream_ops: ops };
2632 return FS.devices[dev];
2652 var mounts = FS.getMounts(FS.root.mount);
2680 if (root && FS.root) {
2681 throw new FS
2683 var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
2688 if (FS.isMountpoint(node)) {
2689 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
2692 if (!FS.isDir(node.mode)) {
2693 throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
2704 // create a root node for the fs
2710 FS.root = mountRoot;
2723 var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
2725 if (!FS.isMountpoint(lookup.node)) {
2726 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2732 var mounts = FS.getMounts(mount);
2734 Object.keys(FS.nameTable).forEach(function (hash) {
2735 var current = FS.nameTable[hash];
2741 FS.destroyNode(current);
2758 var lookup = FS.lookupPath(path, { parent: true });
2761 var err = FS.mayCreate(parent, name);
2763 throw new FS.ErrnoError(err);
2766 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2773 return FS.mknod(path, mode, 0);
2778 return FS.mknod(path, mode, 0);
2785 return FS.mknod(path, mode, dev);
2787 var lookup = FS.lookupPath(newpath, { parent: true });
2790 var err = FS.mayCreate(parent, newname);
2792 throw new FS.ErrnoError(err);
2795 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2806 lookup = FS.lookupPath(old_path, { parent: true });
2808 lookup = FS.lookupPath(new_path, { parent: true });
2811 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
2815 throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
2818 var old_node = FS.lookupNode(old_dir, old_name);
2822 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2827 throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
2832 new_node = FS.lookupNode(new_dir, new_name);
2841 var isdir = FS.isDir(old_node.mode);
2842 var err = FS.mayDelete(old_dir, old_name, isdir);
2844 throw new FS.ErrnoError(err);
2849 FS.mayDelete(new_dir, new_name, isdir) :
2850 FS.mayCreate(new_dir, new_name);
2852 throw new FS.ErrnoError(err);
2855 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2857 if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
2858 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
2862 err = FS.nodePermissions(old_dir, 'w');
2864 throw new FS.ErrnoError(err);
2868 FS.hashRemoveNode(old_node);
2869 // do the underlying fs rename
2877 FS.hashAddNode(old_node);
2880 var lookup = FS.lookupPath(path, { parent: true });
2883 var node = FS.lookupNode(parent, name);
2884 var err = FS.mayDelete(parent, name, true);
2886 throw new FS.ErrnoError(err);
2889 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2891 if (FS.isMountpoint(node)) {
2892 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
2895 FS.destroyNode(node);
2897 var lookup = FS.lookupPath(path, { follow: true });
2900 throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
2904 var lookup = FS.lookupPath(path, { parent: true });
2907 var node = FS.lookupNode(parent, name);
2908 var err = FS.mayDelete(parent, name, false);
2912 throw new FS.ErrnoError(err);
2915 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2917 if (FS.isMountpoint(node)) {
2918 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
2921 FS.destroyNode(node);
2923 var lookup = FS.lookupPath(path);
2926 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2930 var lookup = FS.lookupPath(path, { follow: !dontFollow });
2933 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2937 return FS.stat(path, true);
2941 var lookup = FS.lookupPath(path, { follow: !dontFollow });
2947 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2954 FS.chmod(path, mode, true);
2956 var stream = FS.getStream(fd);
2958 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
2960 FS.chmod(stream.node, mode);
2964 var lookup = FS.lookupPath(path, { follow: !dontFollow });
2970 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2977 FS.chown(path, uid, gid, true);
2979 var stream = FS.getStream(fd);
2981 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
2983 FS.chown(stream.node, uid, gid);
2986 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2990 var lookup = FS.lookupPath(path, { follow: true });
2996 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2998 if (FS.isDir(node.mode)) {
2999 throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
3001 if (!FS.isFile(node.mode)) {
3002 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3004 var err = FS.nodePermissions(node, 'w');
3006 throw new FS.ErrnoError(err);
3013 var stream = FS.getStream(fd);
3015 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3018 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3020 FS.truncate(stream.node, len);
3022 var lookup = FS.lookupPath(path, { follow: true });
3028 flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
3041 var lookup = FS.lookupPath(path, {
3054 throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
3058 node = FS.mknod(path, mode, 0);
3062 throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
3065 if (FS.isChrdev(node.mode)) {
3069 var err = FS.mayOpen(node, flags);
3071 throw new FS.ErrnoError(err);
3075 FS.truncate(node, 0);
3081 var stream = FS.createStream({
3083 path: FS.getPath(node), // we want the absolute path to the node
3097 if (!FS.readFiles) FS.readFiles = {};
3098 if (!(path in FS.readFiles)) {
3099 FS.readFiles[path] = 1;
3112 FS.closeStream(stream.fd);
3116 throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
3121 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3124 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3126 if (FS.isDir(stream.node.mode)) {
3127 throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
3130 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3137 throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
3144 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3147 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3149 if (FS.isDir(stream.node.mode)) {
3150 throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
3153 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3160 throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
3164 FS.llseek(stream, 0, 2);
3171 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3174 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3176 if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
3177 throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
3180 throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
3186 throw new FS.ErrnoError(ERRNO_CODES.EACCES);
3189 throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
3194 throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
3205 var stream = FS.open(path, opts.flags);
3206 var stat = FS.stat(path);
3209 FS.read(stream, buf, 0, length, 0);
3219 FS.close(stream);
3228 var stream = FS.open(path, opts.flags, opts.mode);
3232 FS.write(stream, buf, 0, buf.length, 0, opts.canOwn);
3234 FS.write(stream, data, 0, data.length, 0, opts.canOwn);
3236 FS.close(stream);
3238 return FS.currentPath;
3240 var lookup = FS.lookupPath(path, { follow: true });
3241 if (!FS.isDir(lookup.node.mode)) {
3242 throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
3244 var err = FS.nodePermissions(lookup.node, 'x');
3246 throw new FS.ErrnoError(err);
3248 FS.currentPath = lookup.path;
3250 FS.mkdir('/tmp');
3253 FS.mkdir('/dev');
3255 FS.registerDevice(FS.makedev(1, 3), {
3259 FS.mkdev('/dev/null', FS.makedev(1, 3));
3263 TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
3264 TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
3265 FS.mkdev('/dev/tty', FS.makedev(5, 0));
3266 FS.mkdev('/dev/tty1', FS.makedev(6, 0));
3269 FS.mkdir('/dev/shm');
3270 FS.mkdir('/dev/shm/tmp');
3273 // input / output callback and that utilizes FS.createDevice
3281 FS.createDevice('/dev', 'stdin', Module['stdin']);
3283 FS.symlink('/dev/tty', '/dev/stdin');
3286 FS.createDevice('/dev', 'stdout', null, Module['stdout']);
3288 FS.symlink('/dev/tty', '/dev/stdout');
3291 FS.createDevice('/dev', 'stderr', null, Module['stderr']);
3293 FS.symlink('/dev/tty1', '/dev/stderr');
3297 var stdin = FS.open('/dev/stdin', 'r');
3298 HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
3301 var stdout = FS.open('/dev/stdout', 'w');
3302 HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
3305 var stderr = FS.open('/dev/stderr', 'w');
3306 HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
3309 if (FS.ErrnoError) return;
3310 FS.ErrnoError = function ErrnoError(errno) {
3320 FS.ErrnoError.prototype = new Error();
3321 FS.ErrnoError.prototype.constructor = FS.ErrnoError;
3324 FS.genericErrors[code] = new FS.ErrnoError(code);
3325 FS.genericErrors[code].stack = '<generic error, no stack>';
3328 FS.ensureErrnoError();
3330 FS.nameTable = new Array(4096);
3332 FS.mount(MEMFS, {}, '/');
3334 FS.createDefaultDirectories();
3335 FS.createDefaultDevices();
3337 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)');
3338 FS.init.initialized = true;
3340 FS.ensureErrnoError();
3347 FS.createStandardStreams();
3349 FS.init.initialized = false;
3350 for (var i = 0; i < FS.streams.length; i++) {
3351 var stream = FS.streams[i];
3355 FS.close(stream);
3371 var ret = FS.analyzePath(path, dontResolveLastLink);
3381 var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
3390 var lookup = FS.lookupPath(path, { parent: true });
3395 lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
3406 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
3407 var mode = FS.getMode(canRead, canWrite);
3408 return FS.mkdir(path, mode);
3410 parent = typeof parent === 'string' ? parent : FS.getPath(parent);
3417 FS.mkdir(current);
3425 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
3426 var mode = FS.getMode(canRead, canWrite);
3427 return FS.create(path, mode);
3429 var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
3430 var mode = FS.getMode(canRead, canWrite);
3431 var node = FS.create(path, mode);
3439 FS.chmod(node, mode | 146);
3440 var stream = FS.open(node, 'w');
3441 FS.write(stream, data, 0, data.length, 0, canOwn);
3442 FS.close(stream);
3443 FS.chmod(node, mode);
3447 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
3448 var mode = FS.getMode(!!input, !!output);
3449 if (!FS.createDevice.major) FS.createDevice.major = 64;
3450 var dev = FS.makedev(FS.createDevice.major++, 0);
3453 FS.registerDevice(dev, {
3470 throw new FS.ErrnoError(ERRNO_CODES.EIO);
3473 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
3489 throw new FS.ErrnoError(ERRNO_CODES.EIO);
3498 return FS.mkdev(path, mode, dev);
3500 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
3501 return FS.symlink(target, path);
3616 var node = FS.createFile(parent, name, properties, canRead, canWrite);
3632 if (!FS.forceLoadFile(node)) {
3633 throw new FS.ErrnoError(ERRNO_CODES.EIO);
3640 if (!FS.forceLoadFile(node)) {
3641 throw new FS.ErrnoError(ERRNO_CODES.EIO);
3669 FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
3702 var indexedDB = FS.indexedDB();
3704 var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
3711 db.createObjectStore(FS.DB_STORE_NAME);
3715 var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
3716 var files = transaction.objectStore(FS.DB_STORE_NAME);
3722 var putRequest = files.put(FS.analyzePath(path).object.contents, path);
3732 var indexedDB = FS.indexedDB();
3734 var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
3742 var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
3747 var files = transaction.objectStore(FS.DB_STORE_NAME);
3755 if (FS.analyzePath(path).exists) {
3756 FS.unlink(path);
3758 FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
3836 var path = (i >= 0) ? arguments[i] : FS.cwd();
4418 return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
4439 var node = FS.createNode(SOCKFS.root, name, 49152, 0);
4444 var stream = FS.createStream({
4447 flags: FS.modeStringToFlags('r+'),
4458 var stream = FS.getStream(fd);
4459 if (!stream || !FS.isSocket(stream.node.mode)) {
4556 throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
4710 throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
4728 if (!(e instanceof FS.ErrnoError)) throw e;
4734 throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
4746 throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
4748 throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
4760 throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
4763 throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
4766 throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
4802 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
4811 throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
4832 throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
4846 throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
4848 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
4881 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
4887 throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
4897 throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
4905 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
4908 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
4946 var stream = FS.getStream(fildes);
4953 return FS.write(stream, slab, buf, nbyte, offset);
4955 FS.handleFSError(e);
4961 var stream = FS.getStream(fildes);
4970 return FS.write(stream, slab, buf, nbyte);
4972 FS.handleFSError(e);
4980 stream = FS.getStreamFromPtr(stream);
4991 var streamObj = FS.getStreamFromPtr(stream);
5428 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;
5431 if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
5432 __ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
