Skip to content

Commit 769be84

Browse files
ShogunPandaShogunPanda
committed
fixup
Signed-off-by: Paolo Insogna <[email protected]>
1 parent c44780a commit 769be84

5 files changed

Lines changed: 127 additions & 72 deletions

File tree

‎src/env_properties.h‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -81,6 +81,7 @@
8181
V(allow_unknown_named_params_string, "allowUnknownNamedParameters") \
8282
V(alpn_callback_string, "ALPNCallback") \
8383
V(args_string, "args") \
84+
V(arguments_string, "arguments") \
8485
V(async_ids_stack_string, "async_ids_stack") \
8586
V(attributes_string, "attributes") \
8687
V(backup_string, "backup") \
@@ -288,10 +289,12 @@
288289
V(password_string, "password") \
289290
V(path_string, "path") \
290291
V(pathname_string, "pathname") \
292+
V(parameters_string, "parameters") \
291293
V(pending_handle_string, "pendingHandle") \
292294
V(permission_string, "permission") \
293295
V(phase_string, "phase") \
294296
V(pid_string, "pid") \
297+
V(pointer_string, "pointer") \
295298
V(ping_rtt_string, "pingRTT") \
296299
V(pipe_source_string, "pipeSource") \
297300
V(pipe_string, "pipe") \
@@ -322,6 +325,8 @@
322325
V(require_string, "require") \
323326
V(resource_string, "resource") \
324327
V(result_string, "result") \
328+
V(return_string, "return") \
329+
V(returns_string, "returns") \
325330
V(return_arrays_string, "returnArrays") \
326331
V(salt_length_string, "saltLength") \
327332
V(search_string, "search") \

‎src/ffi/data.cc‎

Lines changed: 16 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33
#include "data.h"
44
#include "base_object-inl.h"
55
#include "node_errors.h"
6+
#include "util.h"
67
#include "v8.h"
78

89
#include <cmath>
@@ -154,7 +155,7 @@ bool ValidatePointerSpan(Environment* env,
154155

155156
bool ValidateBufferLength(Environment* env, size_t len) {
156157
if (len > Buffer::kMaxLength) {
157-
env->isolate()->ThrowException(ERR_BUFFER_TOO_LARGE(env->isolate()));
158+
THROW_ERR_BUFFER_TOO_LARGE(env, "Buffer is too large");
158159
return false;
159160
}
160161

@@ -163,7 +164,7 @@ bool ValidateBufferLength(Environment* env, size_t len) {
163164

164165
bool ValidateStringLength(Environment* env, size_t len) {
165166
if (len > static_cast<size_t>(String::kMaxLength)) {
166-
env->isolate()->ThrowException(ERR_STRING_TOO_LONG(env->isolate()));
167+
THROW_ERR_STRING_TOO_LONG(env, "String is too long");
167168
return false;
168169
}
169170

@@ -368,8 +369,8 @@ void SetValue(const FunctionCallbackInfo<Value>& args) {
368369
int64_t validated;
369370
if (!GetValidatedSignedInt(env,
370371
value,
371-
-9007199254740991LL,
372-
9007199254740991LL,
372+
-static_cast<int64_t>(kMaxSafeJsInteger),
373+
static_cast<int64_t>(kMaxSafeJsInteger),
373374
"int64",
374375
&validated)) {
375376
return;
@@ -389,8 +390,11 @@ void SetValue(const FunctionCallbackInfo<Value>& args) {
389390
}
390391
} else if (value->IsNumber()) {
391392
uint64_t validated;
392-
if (!GetValidatedUnsignedInt(
393-
env, value, 9007199254740991ULL, "uint64", &validated)) {
393+
if (!GetValidatedUnsignedInt(env,
394+
value,
395+
static_cast<uint64_t>(kMaxSafeJsInteger),
396+
"uint64",
397+
&validated)) {
394398
return;
395399
}
396400
converted = static_cast<T>(validated);
@@ -400,13 +404,14 @@ void SetValue(const FunctionCallbackInfo<Value>& args) {
400404
}
401405
} else if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>) {
402406
MaybeLocal<Number> number = value->ToNumber(context);
407+
Local<Number> number_local;
403408

404-
if (number.IsEmpty()) {
409+
if (!number.ToLocal(&number_local)) {
405410
env->ThrowTypeError("Value must be a number");
406411
return;
407412
}
408413

409-
converted = static_cast<T>(number.ToLocalChecked()->Value());
414+
converted = static_cast<T>(number_local->Value());
410415
}
411416

412417
std::memcpy(ptr + offset, &converted, sizeof(converted));
@@ -504,7 +509,7 @@ void ToString(const FunctionCallbackInfo<Value>& args) {
504509
THROW_IF_INSUFFICIENT_PERMISSIONS(env, permission::PermissionScope::kFFI, "");
505510

506511
if (args.Length() < 1 || !args[0]->IsBigInt()) {
507-
env->ThrowTypeError("The first argument must be a bigint");
512+
THROW_ERR_INVALID_ARG_TYPE(env, "The first argument must be a bigint");
508513
return;
509514
}
510515

@@ -544,7 +549,7 @@ void ToBuffer(const FunctionCallbackInfo<Value>& args) {
544549
// validity, lifetime, and bounds.
545550

546551
if (args.Length() < 1 || !args[0]->IsBigInt()) {
547-
env->ThrowTypeError("The first argument must be a bigint");
552+
THROW_ERR_INVALID_ARG_TYPE(env, "The first argument must be a bigint");
548553
return;
549554
}
550555

@@ -604,7 +609,7 @@ void ToArrayBuffer(const FunctionCallbackInfo<Value>& args) {
604609
THROW_IF_INSUFFICIENT_PERMISSIONS(env, permission::PermissionScope::kFFI, "");
605610

606611
if (args.Length() < 1 || !args[0]->IsBigInt()) {
607-
env->ThrowTypeError("The first argument must be a bigint");
612+
THROW_ERR_INVALID_ARG_TYPE(env, "The first argument must be a bigint");
608613
return;
609614
}
610615

‎src/ffi/types.cc‎

Lines changed: 9 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@ using v8::FunctionCallbackInfo;
2222
using v8::Integer;
2323
using v8::Isolate;
2424
using v8::Local;
25+
using v8::Maybe;
2526
using v8::Number;
2627
using v8::Object;
2728
using v8::String;
@@ -59,7 +60,7 @@ bool HasProperty(Local<Context> context,
5960
Local<Object> object,
6061
Local<String> key,
6162
bool* out) {
62-
v8::Maybe<bool> has = object->Has(context, key);
63+
Maybe<bool> has = object->Has(context, key);
6364
if (has.IsNothing()) {
6465
return false;
6566
}
@@ -107,16 +108,11 @@ bool ParseFunctionSignature(Environment* env,
107108
ffi_type** return_type,
108109
std::vector<ffi_type*>* args) {
109110
Local<Context> context = env->context();
110-
Local<String> returns_key =
111-
String::NewFromUtf8Literal(env->isolate(), "returns");
112-
Local<String> return_key =
113-
String::NewFromUtf8Literal(env->isolate(), "return");
114-
Local<String> result_key =
115-
String::NewFromUtf8Literal(env->isolate(), "result");
116-
Local<String> parameters_key =
117-
String::NewFromUtf8Literal(env->isolate(), "parameters");
118-
Local<String> arguments_key =
119-
String::NewFromUtf8Literal(env->isolate(), "arguments");
111+
Local<String> returns_key = env->returns_string();
112+
Local<String> return_key = env->return_string();
113+
Local<String> result_key = env->result_string();
114+
Local<String> parameters_key = env->parameters_string();
115+
Local<String> arguments_key = env->arguments_string();
120116

121117
bool has_returns;
122118
bool has_return;
@@ -406,7 +402,7 @@ uint8_t ToFFIArgument(Environment* env,
406402

407403
*static_cast<double*>(ret) = arg->NumberValue(context).FromJust();
408404
} else if (type == &ffi_type_pointer) {
409-
if (arg->IsNull() || arg->IsUndefined()) {
405+
if (arg->IsNullOrUndefined()) {
410406
*static_cast<uint64_t*>(ret) = reinterpret_cast<uint64_t>(nullptr);
411407
} else if (arg->IsString()) {
412408
// This will handled in Invoke so that we can free the copied string after
@@ -654,7 +650,7 @@ bool ToFFIReturnValue(Local<Value> result, ffi_type* type, void* ret) {
654650
} else if (type == &ffi_type_pointer) {
655651
bool lossless;
656652

657-
if (result->IsNull() || result->IsUndefined()) {
653+
if (result->IsNullOrUndefined()) {
658654
*static_cast<uint64_t*>(ret) = reinterpret_cast<uint64_t>(nullptr);
659655
} else if (result->IsBigInt()) {
660656
uint64_t pointer = result.As<BigInt>()->Uint64Value(&lossless);

‎src/node_ffi.cc‎

Lines changed: 96 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -188,7 +188,7 @@ void DynamicLibrary::CleanupFunctionInfo(
188188
delete info;
189189
}
190190

191-
Local<Function> DynamicLibrary::CreateFunction(
191+
MaybeLocal<Function> DynamicLibrary::CreateFunction(
192192
Environment* env,
193193
const std::string& name,
194194
const std::shared_ptr<FFIFunction>& fn) {
@@ -197,21 +197,32 @@ Local<Function> DynamicLibrary::CreateFunction(
197197
FFIFunctionInfo* info = new FFIFunctionInfo();
198198
info->fn = fn;
199199
Local<External> data = External::New(isolate, info);
200-
Local<Function> ret =
201-
Function::New(env->context(), DynamicLibrary::InvokeFunction, data)
202-
.ToLocalChecked();
200+
MaybeLocal<Function> maybe_ret =
201+
Function::New(env->context(), DynamicLibrary::InvokeFunction, data);
202+
Local<Function> ret;
203+
if (!maybe_ret.ToLocal(&ret)) {
204+
return MaybeLocal<Function>();
205+
}
206+
207+
Local<String> name_str;
208+
if (!String::NewFromUtf8(isolate, name.c_str(), NewStringType::kNormal)
209+
.ToLocal(&name_str)) {
210+
return MaybeLocal<Function>();
211+
}
212+
203213
info->self.Reset(isolate, ret);
204214
info->self.SetWeak(
205215
info, DynamicLibrary::CleanupFunctionInfo, WeakCallbackType::kParameter);
206-
ret->SetName(
207-
String::NewFromUtf8(isolate, name.c_str(), NewStringType::kNormal)
208-
.ToLocalChecked());
209-
ret->Set(env->context(),
210-
FIXED_ONE_BYTE_STRING(env->isolate(), "pointer"),
211-
BigInt::NewFromUnsigned(
212-
isolate,
213-
static_cast<uint64_t>(reinterpret_cast<uintptr_t>(fn->ptr))))
214-
.Check();
216+
ret->SetName(name_str);
217+
if (!ret->Set(
218+
env->context(),
219+
env->pointer_string(),
220+
BigInt::NewFromUnsigned(
221+
isolate,
222+
static_cast<uint64_t>(reinterpret_cast<uintptr_t>(fn->ptr))))
223+
.FromMaybe(false)) {
224+
return MaybeLocal<Function>();
225+
}
215226

216227
return ret;
217228
}
@@ -386,7 +397,14 @@ void DynamicLibrary::InvokeCallback(ffi_cif* cif,
386397
ABORT();
387398
}
388399

389-
Local<Value> result_val = result.ToLocalChecked();
400+
Local<Value> result_val;
401+
if (!result.ToLocal(&result_val)) {
402+
if (try_catch.HasCaught()) {
403+
FPrintF(stderr, "Callbacks cannot return an exception\n");
404+
ABORT();
405+
}
406+
return;
407+
}
390408

391409
if (result_val->IsPromise()) {
392410
FPrintF(stderr, "Callbacks cannot return promises\n");
@@ -402,10 +420,14 @@ void DynamicLibrary::InvokeCallback(ffi_cif* cif,
402420
void DynamicLibrary::GetPath(const FunctionCallbackInfo<Value>& args) {
403421
DynamicLibrary* lib = Unwrap<DynamicLibrary>(args.This());
404422

405-
args.GetReturnValue().Set(String::NewFromUtf8(args.GetIsolate(),
406-
lib->path_.c_str(),
407-
NewStringType::kNormal)
408-
.ToLocalChecked());
423+
Local<String> path;
424+
if (!String::NewFromUtf8(
425+
args.GetIsolate(), lib->path_.c_str(), NewStringType::kNormal)
426+
.ToLocal(&path)) {
427+
return;
428+
}
429+
430+
args.GetReturnValue().Set(path);
409431
}
410432

411433
void DynamicLibrary::GetFunction(const FunctionCallbackInfo<Value>& args) {
@@ -448,7 +470,11 @@ void DynamicLibrary::GetFunction(const FunctionCallbackInfo<Value>& args) {
448470
lib->functions_.emplace(*name, fn);
449471
}
450472

451-
Local<Function> ret = lib->CreateFunction(env, *name, fn);
473+
MaybeLocal<Function> maybe_ret = lib->CreateFunction(env, *name, fn);
474+
Local<Function> ret;
475+
if (!maybe_ret.ToLocal(&ret)) {
476+
return;
477+
}
452478
args.GetReturnValue().Set(ret);
453479
}
454480

@@ -539,27 +565,43 @@ void DynamicLibrary::GetFunctions(const FunctionCallbackInfo<Value>& args) {
539565
}
540566

541567
for (const auto& item : pending) {
542-
Local<Function> ret = lib->CreateFunction(env, item.name, item.fn);
543-
544-
functions
545-
->Set(context,
546-
String::NewFromUtf8(
547-
isolate, item.name.c_str(), NewStringType::kNormal)
548-
.ToLocalChecked(),
549-
ret)
550-
.Check();
568+
MaybeLocal<Function> maybe_ret =
569+
lib->CreateFunction(env, item.name, item.fn);
570+
Local<Function> ret;
571+
if (!maybe_ret.ToLocal(&ret)) {
572+
return;
573+
}
574+
575+
Local<String> name_string;
576+
if (!String::NewFromUtf8(
577+
isolate, item.name.c_str(), NewStringType::kNormal)
578+
.ToLocal(&name_string)) {
579+
return;
580+
}
581+
582+
if (!functions->Set(context, name_string, ret).FromMaybe(false)) {
583+
return;
584+
}
551585
}
552586
} else {
553587
for (const auto& entry : lib->functions_) {
554-
Local<Function> fn = lib->CreateFunction(env, entry.first, entry.second);
555-
556-
functions
557-
->Set(context,
558-
String::NewFromUtf8(
559-
isolate, entry.first.c_str(), NewStringType::kNormal)
560-
.ToLocalChecked(),
561-
fn)
562-
.Check();
588+
MaybeLocal<Function> maybe_fn =
589+
lib->CreateFunction(env, entry.first, entry.second);
590+
Local<Function> fn;
591+
if (!maybe_fn.ToLocal(&fn)) {
592+
return;
593+
}
594+
595+
Local<String> name_string;
596+
if (!String::NewFromUtf8(
597+
isolate, entry.first.c_str(), NewStringType::kNormal)
598+
.ToLocal(&name_string)) {
599+
return;
600+
}
601+
602+
if (!functions->Set(context, name_string, fn).FromMaybe(false)) {
603+
return;
604+
}
563605
}
564606
}
565607

@@ -608,16 +650,23 @@ void DynamicLibrary::GetSymbols(const FunctionCallbackInfo<Value>& args) {
608650
return;
609651
}
610652
for (const auto& entry : lib->symbols_) {
611-
symbols
612-
->Set(context,
613-
String::NewFromUtf8(
614-
isolate, entry.first.c_str(), NewStringType::kNormal)
615-
.ToLocalChecked(),
616-
BigInt::NewFromUnsigned(
617-
isolate,
618-
static_cast<uint64_t>(
619-
reinterpret_cast<uintptr_t>(entry.second))))
620-
.Check();
653+
Local<String> symbol_key;
654+
if (!String::NewFromUtf8(
655+
isolate, entry.first.c_str(), NewStringType::kNormal)
656+
.ToLocal(&symbol_key)) {
657+
return;
658+
}
659+
660+
if (!symbols
661+
->Set(context,
662+
symbol_key,
663+
BigInt::NewFromUnsigned(
664+
isolate,
665+
static_cast<uint64_t>(
666+
reinterpret_cast<uintptr_t>(entry.second))))
667+
.FromMaybe(false)) {
668+
return;
669+
}
621670
}
622671

623672
args.GetReturnValue().Set(symbols);

‎src/node_ffi.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -104,7 +104,7 @@ class DynamicLibrary : public BaseObject {
104104
std::shared_ptr<FFIFunction>* ret,
105105
bool* should_cache_symbol,
106106
bool* should_cache_function);
107-
v8::Local<v8::Function> CreateFunction(
107+
v8::MaybeLocal<v8::Function> CreateFunction(
108108
Environment* env,
109109
const std::string& name,
110110
const std::shared_ptr<FFIFunction>& fn);

0 commit comments

Comments
 (0)