Lines Matching refs:FS
57 var nodeFS = require('fs');
1454 // // currently, FS.init does not distinguish if process.stdin is a file or TTY
1457 // // with text files until FS.init can be refactored.
1472 FS.registerDevice(dev, TTY.stream_ops);
1476 throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
1487 throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
1495 throw new FS.ErrnoError(ERRNO_CODES.EIO);
1498 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
1510 throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
1516 throw new FS.ErrnoError(ERRNO_CODES.EIO);
1573 if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
1575 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
1621 stream: FS.chrdev_stream_ops
1625 var node = FS.createNode(parent, name, mode, dev);
1626 if (FS.isDir(node.mode)) {
1630 } else if (FS.isFile(node.mode)) {
1635 } else if (FS.isLink(node.mode)) {
1638 } else if (FS.isChrdev(node.mode)) {
1657 attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
1664 if (FS.isDir(node.mode)) {
1666 } else if (FS.isFile(node.mode)) {
1668 } else if (FS.isLink(node.mode)) {
1695 throw FS.genericErrors[ERRNO_CODES.ENOENT];
1700 if (FS.isDir(old_node.mode)) {
1703 new_node = FS.lookupNode(new_dir, new_name);
1708 throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
1720 var node = FS.lookupNode(parent, name);
1722 throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
1739 if (!FS.isLink(node.mode)) {
1740 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
1785 if (FS.isFile(stream.node.mode)) {
1790 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
1801 if (!FS.isFile(stream.node.mode)) {
1802 throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
1826 throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
1900 var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
1907 stat = FS.stat(path);
1912 if (FS.isDir(stat.mode)) {
1913 check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
1948 var lookup = FS.lookupPath(path);
1950 stat = FS.stat(path);
1955 if (FS.isDir(stat.mode)) {
1957 } else if (FS.isFile(stat.mode)) {
1964 if (FS.isDir(entry.mode)) {
1965 FS.mkdir(path, entry.mode);
1966 } else if (FS.isFile(entry.mode)) {
1967 FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true });
1972 FS.utime(path, entry.timestamp, entry.timestamp);
1980 var lookup = FS.lookupPath(path);
1981 var stat = FS.stat(path);
1983 if (FS.isDir(stat.mode)) {
1984 FS.rmdir(path);
1985 } else if (FS.isFile(stat.mode)) {
1986 FS.unlink(path);
2086 if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
2087 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2089 var node = FS.createNode(parent, name, mode);
2096 stat = fs.lstatSync(path);
2104 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2126 stat = fs.lstatSync(path);
2129 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2158 fs.chmodSync(path, attr.mode);
2164 fs.utimesSync(path, date, date);
2167 fs.truncateSync(path, attr.size);
2171 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2179 // create the backing node for this in the fs root as well
2182 if (FS.isDir(node.mode)) {
2183 fs.mkdirSync(path, node.mode);
2185 fs.writeFileSync(path, '', { mode: node.mode });
2189 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2196 fs.renameSync(oldPath, newPath);
2199 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2204 fs.unlinkSync(path);
2207 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2212 fs.rmdirSync(path);
2215 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2220 return fs.readdirSync(path);
2223 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2228 fs.symlinkSync(oldPath, newPath);
2231 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2236 return fs.readlinkSync(path);
2239 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2244 if (FS.isFile(stream.node.mode)) {
2245 stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
2249 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2253 if (FS.isFile(stream.node.mode) && stream.nfd) {
2254 fs.closeSync(stream.nfd);
2258 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2265 res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
2267 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2280 res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
2282 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2290 if (FS.isFile(stream.node.mode)) {
2292 var stat = fs.fstatSync(stream.nfd);
2295 throw new FS.ErrnoError(ERRNO_CODES[e.code]);
2301 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2318 }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
2319 if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
2322 path = PATH.resolve(FS.cwd(), path);
2336 throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
2345 var current = FS.root;
2355 current = FS.lookupNode(current, parts[i]);
2359 if (FS.isMountpoint(current)) {
2369 while (FS.isLink(current.mode)) {
2370 var link = FS.readlink(current_path);
2373 var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
2377 throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
2387 if (FS.isRoot(node)) {
2402 return ((parentid + hash) >>> 0) % FS.nameTable.length;
2404 var hash = FS.hashName(node.parent.id, node.name);
2405 node.name_next = FS.nameTable[hash];
2406 FS.nameTable[hash] = node;
2408 var hash = FS.hashName(node.parent.id, node.name);
2409 if (FS.nameTable[hash] === node) {
2410 FS.nameTable[hash] = node.name_next;
2412 var current = FS.nameTable[hash];
2422 var err = FS.mayLookup(parent);
2424 throw new FS.ErrnoError(err);
2426 var hash = FS.hashName(parent.id, name);
2427 for (var node = FS.nameTable[hash]; node; node = node.name_next) {
2434 return FS.lookup(parent, name);
2436 if (!FS.FSNode) {
2437 FS.FSNode = function(parent, name, mode, rdev) {
2444 this.id = FS.nextInode++;
2452 FS.FSNode.prototype = {};
2460 Object.defineProperties(FS.FSNode.prototype, {
2470 get: function() { return FS.isDir(this.mode); },
2473 get: function() { return FS.isChrdev(this.mode); },
2478 var node = new FS.FSNode(parent, name, mode, rdev);
2480 FS.hashAddNode(node);
2484 FS.hashRemoveNode(node);
2504 var flags = FS.flagModes[str];
2517 if (FS.ignorePermissions) {
2530 return FS.nodePermissions(dir, 'x');
2533 var node = FS.lookupNode(dir, name);
2537 return FS.nodePermissions(dir, 'wx');
2541 node = FS.lookupNode(dir, name);
2545 var err = FS.nodePermissions(dir, 'wx');
2550 if (!FS.isDir(node.mode)) {
2553 if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
2557 if (FS.isDir(node.mode)) {
2566 if (FS.isLink(node.mode)) {
2568 } else if (FS.isDir(node.mode)) {
2574 return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
2577 fd_end = fd_end || FS.MAX_OPEN_FDS;
2579 if (!FS.streams[fd]) {
2583 throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
2585 return FS.streams[fd];
2587 if (!FS.FSStream) {
2588 FS.FSStream = function(){};
2589 FS.FSStream.prototype = {};
2591 Object.defineProperties(FS.FSStream.prototype, {
2609 stream.__proto__ = FS.FSStream.prototype;
2611 var newStream = new FS.FSStream();
2617 var fd = FS.nextfd(fd_start, fd_end);
2619 FS.streams[fd] = stream;
2622 FS.streams[fd] = null;
2624 return FS.streams[ptr - 1];
2628 var device = FS.getDevice(stream.node.rdev);
2636 throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
2644 FS.devices[dev] = { stream_ops: ops };
2646 return FS.devices[dev];
2666 var mounts = FS.getMounts(FS.root.mount);
2694 if (root && FS.root) {
2695 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
2697 var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
2702 if (FS.isMountpoint(node)) {
2703 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
2706 if (!FS.isDir(node.mode)) {
2707 throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
2718 // create a root node for the fs
2724 FS.root = mountRoot;
2737 var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
2739 if (!FS.isMountpoint(lookup.node)) {
2740 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2746 var mounts = FS.getMounts(mount);
2748 Object.keys(FS.nameTable).forEach(function (hash) {
2749 var current = FS.nameTable[hash];
2755 FS.destroyNode(current);
2772 var lookup = FS.lookupPath(path, { parent: true });
2775 var err = FS.mayCreate(parent, name);
2777 throw new FS.ErrnoError(err);
2780 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2787 return FS.mknod(path, mode, 0);
2792 return FS.mknod(path, mode, 0);
2799 return FS.mknod(path, mode, dev);
2801 var lookup = FS.lookupPath(newpath, { parent: true });
2804 var err = FS.mayCreate(parent, newname);
2806 throw new FS.ErrnoError(err);
2809 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2820 lookup = FS.lookupPath(old_path, { parent: true });
2822 lookup = FS.lookupPath(new_path, { parent: true });
2825 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
2829 throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
2832 var old_node = FS.lookupNode(old_dir, old_name);
2836 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2841 throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
2846 new_node = FS.lookupNode(new_dir, new_name);
2855 var isdir = FS.isDir(old_node.mode);
2856 var err = FS.mayDelete(old_dir, old_name, isdir);
2858 throw new FS.ErrnoError(err);
2863 FS.mayDelete(new_dir, new_name, isdir) :
2864 FS.mayCreate(new_dir, new_name);
2866 throw new FS.ErrnoError(err);
2869 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2871 if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
2872 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
2876 err = FS.nodePermissions(old_dir, 'w');
2878 throw new FS.ErrnoError(err);
2882 FS.hashRemoveNode(old_node);
2883 // do the underlying fs rename
2891 FS.hashAddNode(old_node);
2894 var lookup = FS.lookupPath(path, { parent: true });
2897 var node = FS.lookupNode(parent, name);
2898 var err = FS.mayDelete(parent, name, true);
2900 throw new FS.ErrnoError(err);
2903 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2905 if (FS.isMountpoint(node)) {
2906 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
2909 FS.destroyNode(node);
2911 var lookup = FS.lookupPath(path, { follow: true });
2914 throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
2918 var lookup = FS.lookupPath(path, { parent: true });
2921 var node = FS.lookupNode(parent, name);
2922 var err = FS.mayDelete(parent, name, false);
2926 throw new FS.ErrnoError(err);
2929 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2931 if (FS.isMountpoint(node)) {
2932 throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
2935 FS.destroyNode(node);
2937 var lookup = FS.lookupPath(path);
2940 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
2944 var lookup = FS.lookupPath(path, { follow: !dontFollow });
2947 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2951 return FS.stat(path, true);
2955 var lookup = FS.lookupPath(path, { follow: !dontFollow });
2961 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2968 FS.chmod(path, mode, true);
2970 var stream = FS.getStream(fd);
2972 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
2974 FS.chmod(stream.node, mode);
2978 var lookup = FS.lookupPath(path, { follow: !dontFollow });
2984 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
2991 FS.chown(path, uid, gid, true);
2993 var stream = FS.getStream(fd);
2995 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
2997 FS.chown(stream.node, uid, gid);
3000 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3004 var lookup = FS.lookupPath(path, { follow: true });
3010 throw new FS.ErrnoError(ERRNO_CODES.EPERM);
3012 if (FS.isDir(node.mode)) {
3013 throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
3015 if (!FS.isFile(node.mode)) {
3016 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3018 var err = FS.nodePermissions(node, 'w');
3020 throw new FS.ErrnoError(err);
3027 var stream = FS.getStream(fd);
3029 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3032 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3034 FS.truncate(stream.node, len);
3036 var lookup = FS.lookupPath(path, { follow: true });
3042 flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
3055 var lookup = FS.lookupPath(path, {
3068 throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
3072 node = FS.mknod(path, mode, 0);
3076 throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
3079 if (FS.isChrdev(node.mode)) {
3083 var err = FS.mayOpen(node, flags);
3085 throw new FS.ErrnoError(err);
3089 FS.truncate(node, 0);
3095 var stream = FS.createStream({
3097 path: FS.getPath(node), // we want the absolute path to the node
3111 if (!FS.readFiles) FS.readFiles = {};
3112 if (!(path in FS.readFiles)) {
3113 FS.readFiles[path] = 1;
3126 FS.closeStream(stream.fd);
3130 throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
3135 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3138 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3140 if (FS.isDir(stream.node.mode)) {
3141 throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
3144 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3151 throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
3158 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3161 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3163 if (FS.isDir(stream.node.mode)) {
3164 throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
3167 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3174 throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
3178 FS.llseek(stream, 0, 2);
3185 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
3188 throw new FS.ErrnoError(ERRNO_CODES.EBADF);
3190 if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
3191 throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
3194 throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
3200 throw new FS.ErrnoError(ERRNO_CODES.EACCES);
3203 throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
3208 throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
3219 var stream = FS.open(path, opts.flags);
3220 var stat = FS.stat(path);
3223 FS.read(stream, buf, 0, length, 0);
3233 FS.close(stream);
3242 var stream = FS.open(path, opts.flags, opts.mode);
3246 FS.write(stream, buf, 0, buf.length, 0, opts.canOwn);
3248 FS.write(stream, data, 0, data.length, 0, opts.canOwn);
3250 FS.close(stream);
3252 return FS.currentPath;
3254 var lookup = FS.lookupPath(path, { follow: true });
3255 if (!FS.isDir(lookup.node.mode)) {
3256 throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
3258 var err = FS.nodePermissions(lookup.node, 'x');
3260 throw new FS.ErrnoError(err);
3262 FS.currentPath = lookup.path;
3264 FS.mkdir('/tmp');
3267 FS.mkdir('/dev');
3269 FS.registerDevice(FS.makedev(1, 3), {
3273 FS.mkdev('/dev/null', FS.makedev(1, 3));
3277 TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
3278 TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
3279 FS.mkdev('/dev/tty', FS.makedev(5, 0));
3280 FS.mkdev('/dev/tty1', FS.makedev(6, 0));
3283 FS.mkdir('/dev/shm');
3284 FS.mkdir('/dev/shm/tmp');
3287 // input / output callback and that utilizes FS.createDevice
3295 FS.createDevice('/dev', 'stdin', Module['stdin']);
3297 FS.symlink('/dev/tty', '/dev/stdin');
3300 FS.createDevice('/dev', 'stdout', null, Module['stdout']);
3302 FS.symlink('/dev/tty', '/dev/stdout');
3305 FS.createDevice('/dev', 'stderr', null, Module['stderr']);
3307 FS.symlink('/dev/tty1', '/dev/stderr');
3311 var stdin = FS.open('/dev/stdin', 'r');
3312 HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
3315 var stdout = FS.open('/dev/stdout', 'w');
3316 HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
3319 var stderr = FS.open('/dev/stderr', 'w');
3320 HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
3323 if (FS.ErrnoError) return;
3324 FS.ErrnoError = function ErrnoError(errno) {
3334 FS.ErrnoError.prototype = new Error();
3335 FS.ErrnoError.prototype.constructor = FS.ErrnoError;
3338 FS.genericErrors[code] = new FS.ErrnoError(code);
3339 FS.genericErrors[code].stack = '<generic error, no stack>';
3342 FS.ensureErrnoError();
3344 FS.nameTable = new Array(4096);
3346 FS.mount(MEMFS, {}, '/');
3348 FS.createDefaultDirectories();
3349 FS.createDefaultDevices();
3351 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)');
3352 FS.init.initialized = true;
3354 FS.ensureErrnoError();
3361 FS.createStandardStreams();
3363 FS.init.initialized = false;
3364 for (var i = 0; i < FS.streams.length; i++) {
3365 var stream = FS.streams[i];
3369 FS.close(stream);
3385 var ret = FS.analyzePath(path, dontResolveLastLink);
3395 var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
3404 var lookup = FS.lookupPath(path, { parent: true });
3409 lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
3420 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
3421 var mode = FS.getMode(canRead, canWrite);
3422 return FS.mkdir(path, mode);
3424 parent = typeof parent === 'string' ? parent : FS.getPath(parent);
3431 FS.mkdir(current);
3439 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
3440 var mode = FS.getMode(canRead, canWrite);
3441 return FS.create(path, mode);
3443 var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
3444 var mode = FS.getMode(canRead, canWrite);
3445 var node = FS.create(path, mode);
3453 FS.chmod(node, mode | 146);
3454 var stream = FS.open(node, 'w');
3455 FS.write(stream, data, 0, data.length, 0, canOwn);
3456 FS.close(stream);
3457 FS.chmod(node, mode);
3461 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
3462 var mode = FS.getMode(!!input, !!output);
3463 if (!FS.createDevice.major) FS.createDevice.major = 64;
3464 var dev = FS.makedev(FS.createDevice.major++, 0);
3467 FS.registerDevice(dev, {
3484 throw new FS.ErrnoError(ERRNO_CODES.EIO);
3487 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
3503 throw new FS.ErrnoError(ERRNO_CODES.EIO);
3512 return FS.mkdev(path, mode, dev);
3514 var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
3515 return FS.symlink(target, path);
3630 var node = FS.createFile(parent, name, properties, canRead, canWrite);
3646 if (!FS.forceLoadFile(node)) {
3647 throw new FS.ErrnoError(ERRNO_CODES.EIO);
3654 if (!FS.forceLoadFile(node)) {
3655 throw new FS.ErrnoError(ERRNO_CODES.EIO);
3683 FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
3716 var indexedDB = FS.indexedDB();
3718 var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
3725 db.createObjectStore(FS.DB_STORE_NAME);
3729 var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
3730 var files = transaction.objectStore(FS.DB_STORE_NAME);
3736 var putRequest = files.put(FS.analyzePath(path).object.contents, path);
3746 var indexedDB = FS.indexedDB();
3748 var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
3756 var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
3761 var files = transaction.objectStore(FS.DB_STORE_NAME);
3769 if (FS.analyzePath(path).exists) {
3770 FS.unlink(path);
3772 FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
3850 var path = (i >= 0) ? arguments[i] : FS.cwd();
4432 return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
4453 var node = FS.createNode(SOCKFS.root, name, 49152, 0);
4458 var stream = FS.createStream({
4461 flags: FS.modeStringToFlags('r+'),
4472 var stream = FS.getStream(fd);
4473 if (!stream || !FS.isSocket(stream.node.mode)) {
4570 throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
4724 throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
4742 if (!(e instanceof FS.ErrnoError)) throw e;
4748 throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
4760 throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
4762 throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
4774 throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
4777 throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
4780 throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
4816 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
4825 throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
4846 throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
4860 throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
4862 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
4895 throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
4901 throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
4911 throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
4919 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
4922 throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
4960 var stream = FS.getStream(fildes);
4967 return FS.write(stream, slab, buf, nbyte, offset);
4969 FS.handleFSError(e);
4975 var stream = FS.getStream(fildes);
4984 return FS.write(stream, slab, buf, nbyte);
4986 FS.handleFSError(e);
4994 stream = FS.getStreamFromPtr(stream);
5005 var streamObj = FS.getStreamFromPtr(stream);
5430 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;
5433 if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
5434 __ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
