fixup! fixup! fixup! fixup! fixup! src,lib: initial ffi implementation

Author: bengl

lib/ffi.js

@@ -37,7 +37,7 @@ const callBufferDV = new DataView(callBuffer);
 
 const libCache = {};
 
-const POINTER_SIZE = sizes['char *'];
+const POINTER_SIZE = sizes['char*'];
 const NULL = Symbol('null');
 
 function isSigned(type) {
@@ -229,7 +229,7 @@ function getBufferPointer(buf) {
 
 function sizeof(typ) {
   if (sizes[typ]) return sizes[typ];
-  if (typ.includes('*')) return sizes['char *'];
+  if (typ.includes('*')) return sizes['char*'];
 }
 
 module.exports = {

src/node_ffi.cc

@@ -23,22 +23,18 @@ using v8::Number;
 namespace node {
 namespace ffi {
 
-static bool lossless = false;
-
-#define ReturnBigInt(isolate, ptr)                                             \
-  args.GetReturnValue().Set(BigInt::NewFromUnsigned(isolate, (uint64_t)ptr))
+#define ReturnPointer(ptr)                                                     \
+  args.GetReturnValue().Set(                                                   \
+      BigInt::NewFromUnsigned(args.GetIsolate(), (uint64_t)ptr))
 
 void GetLibrary(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   THROW_IF_INSUFFICIENT_PERMISSIONS(env, permission::PermissionScope::kFfi, "");
 
-  bool isNull = true;
   std::string fname = "";
-  if (!args[0]->IsNull()) {
-    CHECK(args[0]->IsString());
-    node::Utf8Value filename(env->isolate(), args[0]);
-    fname = filename.ToString();
-    isNull = false;
+  CHECK(args[0]->IsNull() || args[0]->IsString());
+  if (args[0]->IsString()) {
+    fname = *node::Utf8Value(env->isolate(), args[0]);
   }
 
   std::map<std::string, binding::DLib*> libraries =
@@ -47,28 +43,27 @@ void GetLibrary(const FunctionCallbackInfo<Value>& args) {
   if (libraries[fname] != nullptr) {
     lib = libraries[fname];
   } else {
-    if (isNull) {
+    if (fname.empty()) {
       lib = new binding::DLib(binding::DLib::kDefaultFlags);
     } else {
       lib = new binding::DLib(fname.c_str(), binding::DLib::kDefaultFlags);
     }
     if (!lib->Open()) return;
     libraries[fname] = lib;
   }
-  ReturnBigInt(env->isolate(), lib);
+  ReturnPointer(lib);
 }
 
 void GetSymbol(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   THROW_IF_INSUFFICIENT_PERMISSIONS(env, permission::PermissionScope::kFfi, "");
 
   CHECK(args[0]->IsBigInt());
-  binding::DLib* lib =
-      (binding::DLib*)args[0].As<BigInt>()->Uint64Value(&lossless);
+  binding::DLib* lib = (binding::DLib*)args[0].As<BigInt>()->Uint64Value();
   CHECK(args[1]->IsString());
   node::Utf8Value symName(env->isolate(), args[1]);
   void* symbol = lib->GetSymbolAddress(symName.ToString().c_str());
-  ReturnBigInt(env->isolate(), symbol);
+  ReturnPointer(symbol);
 }
 
 void GetBufferPointer(const FunctionCallbackInfo<Value>& args) {
@@ -78,7 +73,7 @@ void GetBufferPointer(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[0]->IsArrayBuffer() || args[0]->IsSharedArrayBuffer());
   void* data = args[0].As<ArrayBuffer>()->Data();
 
-  ReturnBigInt(args.GetIsolate(), data);
+  ReturnPointer(data);
 }
 
 void SetCallBuffer(const FunctionCallbackInfo<Value>& args) {
@@ -87,7 +82,7 @@ void SetCallBuffer(const FunctionCallbackInfo<Value>& args) {
 
   void* callBuffer = ab->Data();
   Realm::GetBindingData<FfiBindingData>(args)->callBuffer = callBuffer;
-  ReturnBigInt(args.GetIsolate(), callBuffer);
+  ReturnPointer(callBuffer);
 }
 
 FfiSignature::FfiSignature(Environment* env,
@@ -99,16 +94,15 @@ FfiSignature::FfiSignature(Environment* env,
   Local<Context> context = env->context();
 
   cif_ = reinterpret_cast<ffi_cif*>(malloc(sizeof(ffi_cif)));
-  fn_ = (void (*)())fn->Uint64Value(&lossless);
+  fn_ = (void (*)())fn->Uint64Value();
   uint32_t argc = argTypes->Length();
   argvTypes_ = reinterpret_cast<ffi_type**>(malloc(sizeof(ffi_type*) * argc));
 
-  ffi_type* retTyp =
-      reinterpret_cast<ffi_type*>(retType->Uint64Value(&lossless));
+  ffi_type* retTyp = reinterpret_cast<ffi_type*>(retType->Uint64Value());
   for (uint32_t i = 0; i < argc; i++) {
     Local<Value> val = argTypes->Get(context, i).ToLocalChecked();
     CHECK(val->IsBigInt());
-    uint64_t arg = val.As<BigInt>()->Uint64Value(&lossless);
+    uint64_t arg = val.As<BigInt>()->Uint64Value();
     argvTypes_[i] = reinterpret_cast<ffi_type*>(arg);
   }