if (err) {
backtrace.stack = err.name + ': ' + err.message +
backtrace.stack.substr(backtrace.name.length);
- err = backtrace;
- throw err;
+ throw backtrace;
}
};
}
}
ReadFileContext.prototype.read = function() {
- var fd = this.fd;
- var size = this.size;
var buffer;
var offset;
var length;
- if (size === 0) {
+ if (this.size === 0) {
buffer = this.buffer = new SlowBuffer(kReadFileBufferLength);
offset = 0;
length = kReadFileBufferLength;
} else {
buffer = this.buffer;
offset = this.pos;
- length = size - this.pos;
+ length = this.size - this.pos;
}
var req = new FSReqWrap();
req.oncomplete = readFileAfterRead;
req.context = this;
- binding.read(fd, buffer, offset, length, -1, req);
+ binding.read(this.fd, buffer, offset, length, -1, req);
};
ReadFileContext.prototype.close = function(err) {
var context = this.context;
if (err) {
- var callback = context.callback;
- callback(err);
+ context.callback(err);
return;
}
if (size === 0) {
buffers = [];
} else {
- var threw = true;
+ threw = true;
try {
buffer = new Buffer(size);
threw = false;
}
var done = false;
+ var bytesRead;
+
while (!done) {
- var threw = true;
+ threw = true;
try {
if (size !== 0) {
- var bytesRead = fs.readSync(fd, buffer, pos, size - pos);
+ bytesRead = fs.readSync(fd, buffer, pos, size - pos);
} else {
// the kernel lies about many files.
// Go ahead and try to read some bytes.
buffer = new Buffer(8192);
- var bytesRead = fs.readSync(fd, buffer, 0, 8192);
+ bytesRead = fs.readSync(fd, buffer, 0, 8192);
if (bytesRead) {
buffers.push(buffer.slice(0, bytesRead));
}
return undefined;
}
-fs.open = function(path, flags, mode, callback) {
- callback = makeCallback(arguments[arguments.length - 1]);
+fs.open = function(path, flags, mode, callback_) {
+ var callback = makeCallback(arguments[arguments.length - 1]);
mode = modeNum(mode, 0o666);
if (!nullCheck(path, callback)) return;
fs.readSync = function(fd, buffer, offset, length, position) {
var legacy = false;
+ var encoding;
+
if (!(buffer instanceof Buffer)) {
// legacy string interface (fd, length, position, encoding, callback)
legacy = true;
- var encoding = arguments[3];
+ encoding = arguments[3];
assertEncoding(encoding);
callback(err, written || 0, buffer);
}
+ var req = new FSReqWrap();
if (buffer instanceof Buffer) {
// if no position is passed then assume null
if (typeof position === 'function') {
position = null;
}
callback = maybeCallback(callback);
- var req = new FSReqWrap();
req.oncomplete = strWrapper;
return binding.writeBuffer(fd, buffer, offset, length, position, req);
}
length = 'utf8';
}
callback = maybeCallback(position);
- var req = new FSReqWrap();
req.oncomplete = bufWrapper;
return binding.writeString(fd, buffer, offset, length, req);
};
}
// allow error to be thrown, but still close fd.
var fd = fs.openSync(path, 'r+');
+ var ret;
+
try {
- var ret = fs.ftruncateSync(fd, len);
+ ret = fs.ftruncateSync(fd, len);
} finally {
fs.closeSync(fd);
}
}
}
-fs.symlink = function(destination, path, type_, callback) {
+fs.symlink = function(destination, path, type_, callback_) {
var type = (typeof type_ === 'string' ? type_ : null);
var callback = makeCallback(arguments[arguments.length - 1]);
// prefer to return the chmod error, if one occurs,
// but still try to close, and report closing errors if they occur.
- var err, err2;
+ var err, err2, ret;
try {
- var ret = fs.fchmodSync(fd, mode);
+ ret = fs.fchmodSync(fd, mode);
} catch (er) {
err = er;
}
binding.futimes(fd, atime, mtime);
};
-function writeAll(fd, buffer, offset, length, position, callback) {
- callback = maybeCallback(arguments[arguments.length - 1]);
+function writeAll(fd, buffer, offset, length, position, callback_) {
+ var callback = maybeCallback(arguments[arguments.length - 1]);
// write(fd, buffer, offset, length, position, callback)
fs.write(fd, buffer, offset, length, position, function(writeErr, written) {
});
}
-fs.writeFile = function(path, data, options, callback) {
+fs.writeFile = function(path, data, options, callback_) {
var callback = maybeCallback(arguments[arguments.length - 1]);
if (!options || typeof options === 'function') {
this.flags = options.flags === undefined ? 'r' : options.flags;
this.mode = options.mode === undefined ? 0o666 : options.mode;
- this.start = options.start === undefined ? undefined : options.start;
- this.end = options.end === undefined ? undefined : options.end;
+ this.start = options.start;
+ this.end = options.end;
this.autoClose = options.autoClose === undefined ? true : options.autoClose;
this.pos = undefined;
this.flags = options.flags === undefined ? 'w' : options.flags;
this.mode = options.mode === undefined ? 0o666 : options.mode;
- this.start = options.start === undefined ? undefined : options.start;
+ this.start = options.start;
this.pos = undefined;
this.bytesWritten = 0;