std::string ret = str;

// Remove everything leading up to and including the final path separator.

std::string::size_type pos = ret.find_last_of(kPathSeparator);

if (pos != std::string::npos) ret = ret.substr(pos + 1);

// Strip away the extension, if any.

if (ret.size() >= extension.size() &&

ret.substr(ret.size() - extension.size()) == extension) {

ret = ret.substr(0, ret.size() - extension.size());

}

return ret;

Local<Object> obj, int fd)

: AsyncWrap(binding_data->env(), obj, AsyncWrap::PROVIDER_FILEHANDLE),

StreamBase(env()),

fd_(fd),

binding_data_(binding_data) {

MakeWeak();

StreamBase::AttachToObject(GetObject());

BindingData* binding_data = Environment::GetBindingData<BindingData>(args);

Environment* env = binding_data->env();

CHECK(args.IsConstructCall());

CHECK(args[0]->IsInt32());

FileHandle* handle =

FileHandle::New(binding_data, args[0].As<Int32>()->Value(), args.This());

if (handle == nullptr) return;

if (args[1]->IsNumber())

handle->read_offset_ = args[1]->IntegerValue(env->context()).FromJust();

if (args[2]->IsNumber())

handle->read_length_ = args[2]->IntegerValue(env->context()).FromJust();

uv_buf_t* bufs,

size_t count,

uv_stream_t* send_handle) {

return UV_ENOSYS; // Not implemented (yet).

if (closed_) return;

uv_fs_t req;

int ret = uv_fs_close(env()->event_loop(), &req, fd_, nullptr);

uv_fs_req_cleanup(&req);

struct err_detail { int ret; int fd; };

err_detail detail { ret, fd_ };

AfterClose();

if (ret < 0) {

// Do not unref this

env()->SetImmediate([detail](Environment* env) {

char msg[70];

snprintf(msg, arraysize(msg),

"Closing file descriptor %d on garbage collection failed",

detail.fd);

// This exception will end up being fatal for the process because

// it is being thrown from within the SetImmediate handler and

// there is no JS stack to bubble it to. In other words, tearing

// down the process is the only reasonable thing we can do here.

HandleScope handle_scope(env->isolate());

env->ThrowUVException(detail.ret, "close", msg);

});

return;

}

// If the close was successful, we still want to emit a process warning

// to notify that the file descriptor was gc'd. We want to be noisy about

// this because not explicitly closing the FileHandle is a bug.

env()->SetUnrefImmediate([detail](Environment* env) {

ProcessEmitWarning(env,

"Closing file descriptor %d on garbage collection",

detail.fd);

if (env->filehandle_close_warning()) {

env->set_filehandle_close_warning(false);

ProcessEmitDeprecationWarning(

env,

"Closing a FileHandle object on garbage collection is deprecated. "

"Please close FileHandle objects explicitly using "

"FileHandle.prototype.close(). In the future, an error will be "

"thrown if a file descriptor is closed during garbage collection.",

"DEP0137").IsNothing();

}

});

Isolate* isolate = env()->isolate();

EscapableHandleScope scope(isolate);

Local<Context> context = env()->context();

auto maybe_resolver = Promise::Resolver::New(context);

CHECK(!maybe_resolver.IsEmpty());

Local<Promise::Resolver> resolver = maybe_resolver.ToLocalChecked();

Local<Promise> promise = resolver.As<Promise>();

CHECK(!reading_);

if (!closed_ && !closing_) {

closing_ = true;

Local<Object> close_req_obj;

if (!env()

->fdclose_constructor_template()

->NewInstance(env()->context())

.ToLocal(&close_req_obj)) {

return MaybeLocal<Promise>();

}

CloseReq* req = new CloseReq(env(), close_req_obj, promise, object());

auto AfterClose = uv_fs_callback_t{[](uv_fs_t* req) {

std::unique_ptr<CloseReq> close(CloseReq::from_req(req));

CHECK_NOT_NULL(close);

close->file_handle()->AfterClose();

Isolate* isolate = close->env()->isolate();

if (req->result < 0) {

HandleScope handle_scope(isolate);

close->Reject(UVException(isolate, req->result, "close"));

} else {

close->Resolve();

}

}};

int ret = req->Dispatch(uv_fs_close, fd_, AfterClose);

if (ret < 0) {

req->Reject(UVException(isolate, ret, "close"));

delete req;

}

} else {

// Already closed. Just reject the promise immediately

resolver->Reject(context, UVException(isolate, UV_EBADF, "close"))

.Check();

}

return scope.Escape(promise);

FileHandle* fd;

ASSIGN_OR_RETURN_UNWRAP(&fd, args.Holder());

Local<Promise> ret;

if (!fd->ClosePromise().ToLocal(&ret)) return;

args.GetReturnValue().Set(ret);

FileHandle* fd;

ASSIGN_OR_RETURN_UNWRAP(&fd, args.Holder());

// Just act as if this FileHandle has been closed.

fd->AfterClose();

closing_ = false;

closed_ = true;

fd_ = -1;

if (reading_ && !persistent().IsEmpty())

EmitRead(UV_EOF);

if (!IsAlive() || IsClosing())

return UV_EOF;

reading_ = true;

if (current_read_)

return 0;

BaseObjectPtr<FileHandleReadWrap> read_wrap;

if (read_length_ == 0) {

EmitRead(UV_EOF);

return 0;

}

{

// Create a new FileHandleReadWrap or re-use one.

// Either way, we need these two scopes for AsyncReset() or otherwise

// for creating the new instance.

HandleScope handle_scope(env()->isolate());

AsyncHooks::DefaultTriggerAsyncIdScope trigger_scope(this);

auto& freelist = binding_data_->file_handle_read_wrap_freelist;

if (freelist.size() > 0) {

read_wrap = std::move(freelist.back());

freelist.pop_back();

// Use a fresh async resource.

// Lifetime is ensured via AsyncWrap::resource_.

Local<Object> resource = Object::New(env()->isolate());

USE(resource->Set(

env()->context(), env()->handle_string(), read_wrap->object()));

read_wrap->AsyncReset(resource);

read_wrap->file_handle_ = this;

} else {

Local<Object> wrap_obj;

if (!env()

->filehandlereadwrap_template()

->NewInstance(env()->context())

.ToLocal(&wrap_obj)) {

return UV_EBUSY;

}

read_wrap = MakeDetachedBaseObject<FileHandleReadWrap>(this, wrap_obj);

}

}

int64_t recommended_read = 65536;

if (read_length_ >= 0 && read_length_ <= recommended_read)

recommended_read = read_length_;

read_wrap->buffer_ = EmitAlloc(recommended_read);

current_read_ = std::move(read_wrap);

current_read_->Dispatch(uv_fs_read,

fd_,

&current_read_->buffer_,

1,

read_offset_,

uv_fs_callback_t{[](uv_fs_t* req) {

FileHandle* handle;

{

FileHandleReadWrap* req_wrap = FileHandleReadWrap::from_req(req);

handle = req_wrap->file_handle_;

CHECK_EQ(handle->current_read_.get(), req_wrap);

}

// ReadStart() checks whether current_read_ is set to determine whether

// a read is in progress. Moving it into a local variable makes sure that

// the ReadStart() call below doesn't think we're still actively reading.

BaseObjectPtr<FileHandleReadWrap> read_wrap =

std::move(handle->current_read_);

int result = req->result;

uv_buf_t buffer = read_wrap->buffer_;

uv_fs_req_cleanup(req);

// Push the read wrap back to the freelist, or let it be destroyed

// once we’re exiting the current scope.

constexpr size_t wanted_freelist_fill = 100;

auto& freelist = handle->binding_data_->file_handle_read_wrap_freelist;

if (freelist.size() < wanted_freelist_fill) {

read_wrap->Reset();

freelist.emplace_back(std::move(read_wrap));

}

if (result >= 0) {

// Read at most as many bytes as we originally planned to.

if (handle->read_length_ >= 0 && handle->read_length_ < result)

result = handle->read_length_;

// If we read data and we have an expected length, decrease it by

// how much we have read.

if (handle->read_length_ >= 0)

handle->read_length_ -= result;

// If we have an offset, increase it by how much we have read.

if (handle->read_offset_ >= 0)

handle->read_offset_ += result;

}

// Reading 0 bytes from a file always means EOF, or that we reached

// the end of the requested range.

if (result == 0)

result = UV_EOF;

handle->EmitRead(result, buffer);

// Start over, if EmitRead() didn’t tell us to stop.

if (handle->reading_)

handle->ReadStart();

}});

return 0;

FileHandleCloseWrap* wrap = static_cast<FileHandleCloseWrap*>(req_wrap);

closing_ = true;

wrap->Dispatch(uv_fs_close, fd_, uv_fs_callback_t{[](uv_fs_t* req) {

FileHandleCloseWrap* wrap = static_cast<FileHandleCloseWrap*>(

FileHandleCloseWrap::from_req(req));

FileHandle* handle = static_cast<FileHandle*>(wrap->stream());

handle->AfterClose();

int result = req->result;

uv_fs_req_cleanup(req);

wrap->Done(result);

}});

return 0;

Local<Value> argv[2] {

Null(env()->isolate()),

value

};

MakeCallback(env()->oncomplete_string(),

value->IsUndefined() ? 1 : arraysize(argv),

argv);

CHECK(args.IsConstructCall());

BindingData* binding_data = Environment::GetBindingData<BindingData>(args);

new FSReqCallback(binding_data, args.This(), args[0]->IsTrue());

: wrap_(wrap),

req_(req),

handle_scope_(wrap->env()->isolate()),

context_scope_(wrap->env()->context()) {

CHECK_EQ(wrap_->req(), req);

wrap_->Reject(UVException(wrap_->env()->isolate(),

req->result,

wrap_->syscall(),

nullptr,

req->path,

wrap_->data()));

if (req_->result < 0) {

Reject(req_);

return false;

}

return true;

FSReqBase* req_wrap = FSReqBase::from_req(req);

FSReqAfterScope after(req_wrap, req);

if (after.Proceed())

req_wrap->Resolve(Undefined(req_wrap->env()->isolate()));

FSReqBase* req_wrap = FSReqBase::from_req(req);

FSReqAfterScope after(req_wrap, req);

if (after.Proceed()) {

req_wrap->ResolveStat(&req->statbuf);

}

FSReqBase* req_wrap = FSReqBase::from_req(req);

FSReqAfterScope after(req_wrap, req);

if (after.Proceed())

req_wrap->Resolve(Integer::New(req_wrap->env()->isolate(), req->result));

FSReqBase* req_wrap = FSReqBase::from_req(req);

FSReqAfterScope after(req_wrap, req);

if (after.Proceed()) {

FileHandle* fd = FileHandle::New(req_wrap->binding_data(), req->result);

if (fd == nullptr) return;

req_wrap->Resolve(fd->object());

}

#ifdef _WIN32

if (path->compare(0, 8, "\\\\?\\UNC\\", 8) == 0) {

*path = path->substr(8);

path->insert(0, "\\\\");

} else if (path->compare(0, 4, "\\\\?\\", 4) == 0) {

*path = path->substr(4);

}

#endif

FSReqBase* req_wrap = FSReqBase::from_req(req);

FSReqAfterScope after(req_wrap, req);

MaybeLocal<Value> path;

Local<Value> error;

if (after.Proceed()) {

if (!req_wrap->continuation_data()->first_path().empty()) {

std::string first_path(req_wrap->continuation_data()->first_path());

FromNamespacedPath(&first_path);

path = StringBytes::Encode(req_wrap->env()->isolate(), first_path.c_str(),

req_wrap->encoding(),

&error);

if (path.IsEmpty())

req_wrap->Reject(error);

else

req_wrap->Resolve(path.ToLocalChecked());

} else {

req_wrap->Resolve(Undefined(req_wrap->env()->isolate()));

}

}

FSReqBase* req_wrap = FSReqBase::from_req(req);

FSReqAfterScope after(req_wrap, req);

MaybeLocal<Value> link;

Local<Value> error;

if (after.Proceed()) {

link = StringBytes::Encode(req_wrap->env()->isolate(),

req->path,

req_wrap->encoding(),

&error);

if (link.IsEmpty())

req_wrap->Reject(error);

else

req_wrap->Resolve(link.ToLocalChecked());

}

FSReqBase* req_wrap = FSReqBase::from_req(req);

FSReqAfterScope after(req_wrap, req);

MaybeLocal<Value> link;

Local<Value> error;

if (after.Proceed()) {

link = StringBytes::Encode(req_wrap->env()->isolate(),

static_cast<const char*>(req->ptr),

req_wrap->encoding(),

&error);

if (link.IsEmpty())

req_wrap->Reject(error);

else

req_wrap->Resolve(link.ToLocalChecked());

}

FSReqBase* req_wrap = FSReqBase::from_req(req);

FSReqAfterScope after(req_wrap, req);

if (!after.Proceed()) {

return;

}

Environment* env = req_wrap->env();

Local<Value> error;

int r;

std::vector<Local<Value>> name_v;

for (int i = 0; ; i++) {

uv_dirent_t ent;

r = uv_fs_scandir_next(req, &ent);

if (r == UV_EOF)

break;

if (r != 0) {

return req_wrap->Reject(UVException(

env->isolate(), r, nullptr, req_wrap->syscall(), req->path));

}

MaybeLocal<Value> filename =

StringBytes::Encode(env->isolate(),

ent.name,

req_wrap->encoding(),

&error);

if (filename.IsEmpty())

return req_wrap->Reject(error);

name_v.push_back(filename.ToLocalChecked());

}

req_wrap->Resolve(Array::New(env->isolate(), name_v.data(), name_v.size()));

FSReqBase* req_wrap = FSReqBase::from_req(req);

FSReqAfterScope after(req_wrap, req);

if (!after.Proceed()) {

return;

}

Environment* env = req_wrap->env();

Isolate* isolate = env->isolate();

Local<Value> error;

int r;

std::vector<Local<Value>> name_v;

std::vector<Local<Value>> type_v;

for (int i = 0; ; i++) {

uv_dirent_t ent;

r = uv_fs_scandir_next(req, &ent);

if (r == UV_EOF)

break;

if (r != 0) {

return req_wrap->Reject(

UVException(isolate, r, nullptr, req_wrap->syscall(), req->path));

}

MaybeLocal<Value> filename =

StringBytes::Encode(isolate,

ent.name,

req_wrap->encoding(),

&error);

if (filename.IsEmpty())

return req_wrap->Reject(error);

name_v.push_back(filename.ToLocalChecked());

type_v.emplace_back(Integer::New(isolate, ent.type));

}

Local<Value> result[] = {

Array::New(isolate, name_v.data(), name_v.size()),

Array::New(isolate, type_v.data(), type_v.size())

};

req_wrap->Resolve(Array::New(isolate, result, arraysize(result)));

Environment* env = Environment::GetCurrent(args);

Isolate* isolate = env->isolate();

HandleScope scope(isolate);

const int argc = args.Length();

CHECK_GE(argc, 2);

CHECK(args[1]->IsInt32());

int mode = args[1].As<Int32>()->Value();

BufferValue path(isolate, args[0]);

CHECK_NOT_NULL(*path);

FSReqBase* req_wrap_async = GetReqWrap(args, 2);

if (req_wrap_async != nullptr) { // access(path, mode, req)

AsyncCall(env, req_wrap_async, args, "access", UTF8, AfterNoArgs,

uv_fs_access, *path, mode);

} else { // access(path, mode, undefined, ctx)

CHECK_EQ(argc, 4);

FSReqWrapSync req_wrap_sync;

FS_SYNC_TRACE_BEGIN(access);

SyncCall(env, args[3], &req_wrap_sync, "access", uv_fs_access, *path, mode);

FS_SYNC_TRACE_END(access);

}

Environment* env = Environment::GetCurrent(args);

const int argc = args.Length();

CHECK_GE(argc, 2);

CHECK(args[0]->IsInt32());

int fd = args[0].As<Int32>()->Value();

FSReqBase* req_wrap_async = GetReqWrap(args, 1);

if (req_wrap_async != nullptr) { // close(fd, req)

AsyncCall(env, req_wrap_async, args, "close", UTF8, AfterNoArgs,

uv_fs_close, fd);

} else { // close(fd, undefined, ctx)

CHECK_EQ(argc, 3);

FSReqWrapSync req_wrap_sync;

FS_SYNC_TRACE_BEGIN(close);

SyncCall(env, args[2], &req_wrap_sync, "close", uv_fs_close, fd);

FS_SYNC_TRACE_END(close);

}

Environment* env = Environment::GetCurrent(args);

Isolate* isolate = env->isolate();

uv_loop_t* loop = env->event_loop();

CHECK(args[0]->IsString());

node::Utf8Value path(isolate, args[0]);

if (strlen(*path) != path.length())

return; // Contains a nul byte.

uv_fs_t open_req;

const int fd = uv_fs_open(loop, &open_req, *path, O_RDONLY, 0, nullptr);

uv_fs_req_cleanup(&open_req);

if (fd < 0) {

return;

}

auto defer_close = OnScopeLeave([fd, loop]() {

uv_fs_t close_req;

CHECK_EQ(0, uv_fs_close(loop, &close_req, fd, nullptr));

uv_fs_req_cleanup(&close_req);

});

const size_t kBlockSize = 32 << 10;

std::vector<char> chars;

int64_t offset = 0;

ssize_t numchars;

do {

const size_t start = chars.size();

chars.resize(start + kBlockSize);

uv_buf_t buf;

buf.base = &chars[start];

buf.len = kBlockSize;

uv_fs_t read_req;

numchars = uv_fs_read(loop, &read_req, fd, &buf, 1, offset, nullptr);

uv_fs_req_cleanup(&read_req);

if (numchars < 0)

return;

offset += numchars;

} while (static_cast<size_t>(numchars) == kBlockSize);

size_t start = 0;

if (offset >= 3 && 0 == memcmp(&chars[0], "\xEF\xBB\xBF", 3)) {

start = 3; // Skip UTF-8 BOM.

}

const size_t size = offset - start;

char* p = &chars[start];

char* pe = &chars[size];

char* pos[2];

char** ppos = &pos[0];

while (p < pe) {

char c = *p++;

if (c == '\\' && p < pe && *p == '"') p++;

if (c != '"') continue;

*ppos++ = p;

if (ppos < &pos[2]) continue;

ppos = &pos[0];

char* s = &pos[0][0];

char* se = &pos[1][-1]; // Exclude quote.

size_t n = se - s;

if (n == 4) {

if (0 == memcmp(s, "main", 4)) break;

if (0 == memcmp(s, "name", 4)) break;

if (0 == memcmp(s, "type", 4)) break;

} else if (n == 7) {

if (0 == memcmp(s, "exports", 7)) break;

}

}

Local<String> return_value;

if (p < pe) {

return_value =

String::NewFromUtf8(isolate,

&chars[start],

v8::NewStringType::kNormal,

size).ToLocalChecked();

} else {

return_value = env->empty_object_string();

}

args.GetReturnValue().Set(return_value);

Environment* env = Environment::GetCurrent(args);

CHECK(args[0]->IsString());

node::Utf8Value path(env->isolate(), args[0]);

uv_fs_t req;

int rc = uv_fs_stat(env->event_loop(), &req, *path, nullptr);

if (rc == 0) {

const uv_stat_t* const s = static_cast<const uv_stat_t*>(req.ptr);

rc = !!(s->st_mode & S_IFDIR);

}

uv_fs_req_cleanup(&req);

args.GetReturnValue().Set(rc);

BindingData* binding_data = Environment::GetBindingData<BindingData>(args);

Environment* env = binding_data->env();

const int argc = args.Length();

CHECK_GE(argc, 2);

BufferValue path(env->isolate(), args[0]);

CHECK_NOT_NULL(*path);

bool use_bigint = args[1]->IsTrue();

FSReqBase* req_wrap_async = GetReqWrap(args, 2, use_bigint);

if (req_wrap_async != nullptr) { // stat(path, use_bigint, req)

AsyncCall(env, req_wrap_async, args, "stat", UTF8, AfterStat,

uv_fs_stat, *path);

} else { // stat(path, use_bigint, undefined, ctx)

CHECK_EQ(argc, 4);

FSReqWrapSync req_wrap_sync;

FS_SYNC_TRACE_BEGIN(stat);

int err = SyncCall(env, args[3], &req_wrap_sync, "stat", uv_fs_stat, *path);

FS_SYNC_TRACE_END(stat);

if (err != 0) {

return; // error info is in ctx

}

Local<Value> arr = FillGlobalStatsArray(binding_data, use_bigint,

static_cast<const uv_stat_t*>(req_wrap_sync.req.ptr));

args.GetReturnValue().Set(arr);

}

BindingData* binding_data = Environment::GetBindingData<BindingData>(args);

Environment* env = binding_data->env();

const int argc = args.Length();

CHECK_GE(argc, 3);

BufferValue path(env->isolate(), args[0]);

CHECK_NOT_NULL(*path);

bool use_bigint = args[1]->IsTrue();

FSReqBase* req_wrap_async = GetReqWrap(args, 2, use_bigint);

if (req_wrap_async != nullptr) { // lstat(path, use_bigint, req)

AsyncCall(env, req_wrap_async, args, "lstat", UTF8, AfterStat,

uv_fs_lstat, *path);

} else { // lstat(path, use_bigint, undefined, ctx)

CHECK_EQ(argc, 4);

FSReqWrapSync req_wrap_sync;

FS_SYNC_TRACE_BEGIN(lstat);

int err = SyncCall(env, args[3], &req_wrap_sync, "lstat", uv_fs_lstat,