koffi 1.1.0-beta.3 → 1.1.0-beta.6

package/CMakeLists.txt

@@ -65,9 +65,6 @@ if(WIN32)
     target_compile_definitions(koffi PRIVATE _CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_DEPRECATE)
     target_link_libraries(koffi PRIVATE ws2_32)
 endif()
-if(MSVC)
-    target_compile_options(koffi PRIVATE /wd4200)
-else()
-    target_compile_options(koffi PRIVATE -fno-exceptions -Wno-missing-field-initializers
-                                         -fno-strict-aliasing)
+if(NOT MSVC)
+    target_compile_options(koffi PRIVATE -fno-exceptions -fno-strict-aliasing)
 endif()

package/README.md

@@ -3,6 +3,7 @@
 - [Introduction](#introduction)
 - [Get started](#get-started)
 - [Extra features](#extra-features)
+  * [Type information](#type-information)
   * [C arrays](#c-arrays)
   * [Variadic functions](#variadic-functions)
   * [Asynchronous calls](#asynchronous-calls)
@@ -218,6 +219,13 @@ while (!WindowShouldClose()) {
 
 # Extra features
 
+## Type information
+
+Koffi exposes three functions to explore type information:
+- `koffi.sizeof(type)` to get the size of a type
+- `koffi.alignof(type)` to get the alignment of a type
+- `koffi.introspect(type)` to get the definition of a type (only for structs for now)
+
 ## C arrays
 
 Fixed-size arrays are declared with `koffi.array(type, length)`. Just like in C, they cannot be passed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koffi",
-  "version": "1.1.0-beta.3",
+  "version": "1.1.0-beta.6",
   "description": "Fast and simple FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",

package/src/call.cc

@@ -20,8 +20,8 @@
 
 namespace RG {
 
-CallData::CallData(Napi::Env env, const FunctionInfo *func, InstanceMemory *mem, bool debug)
-    : env(env), instance(env.GetInstanceData<InstanceData>()), func(func), debug(debug),
+CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func, InstanceMemory *mem)
+    : env(env), instance(instance), func(func), debug(instance->debug),
       mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap)
 {
     mem->depth++;
@@ -67,7 +67,7 @@ const char *CallData::PushString(const Napi::Value &value)
 
         len++;
 
-        buf.ptr = (char *)Allocator::Allocate(&mem->big_alloc, (Size)len);
+        buf.ptr = (char *)Allocator::Allocate(&call_alloc, (Size)len);
         buf.len = (Size)len;
 
         status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
@@ -104,7 +104,7 @@ const char16_t *CallData::PushString16(const Napi::Value &value)
 
         len++;
 
-        buf.ptr = (char16_t *)Allocator::Allocate(&mem->big_alloc, (Size)len * 2);
+        buf.ptr = (char16_t *)Allocator::Allocate(&call_alloc, (Size)len * 2);
         buf.len = (Size)len;
 
         status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
@@ -822,6 +822,19 @@ Napi::Object CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_
     RG_UNREACHABLE();
 }
 
+Napi::Value CallData::Run(const Napi::CallbackInfo &info)
+{
+    if (!RG_UNLIKELY(Prepare(info)))
+        return env.Null();
+
+    if (debug) {
+        DumpDebug();
+    }
+    Execute();
+
+    return Complete();
+}
+
 static void DumpMemory(const char *type, Span<const uint8_t> bytes)
 {
     if (bytes.len) {

package/src/call.hh

@@ -55,26 +55,17 @@ class CallData {
     } result;
     uint8_t *return_ptr = nullptr;
 
+    LinkedAllocator call_alloc;
+
 public:
-    CallData(Napi::Env env, const FunctionInfo *func, InstanceMemory *mem, bool debug);
+    CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func, InstanceMemory *mem);
     ~CallData();
 
     bool Prepare(const Napi::CallbackInfo &info);
     void Execute();
     Napi::Value Complete();
 
-    Napi::Value Run(const Napi::CallbackInfo &info)
-    {
-        if (!RG_UNLIKELY(Prepare(info)))
-            return env.Null();
-
-        if (debug) {
-            DumpDebug();
-        }
-        Execute();
-
-        return Complete();
-    }
+    Napi::Value Run(const Napi::CallbackInfo &info);
 
     void DumpDebug() const;
 

package/src/ffi.cc

@@ -72,6 +72,8 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 
     type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
 
+    type->defn.Reset(obj, 1);
+
     type->primitive = PrimitiveKind::Record;
     type->align = 1;
 
@@ -296,6 +298,61 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     return external;
 }
 
+static Napi::Value GetTypeSize(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+
+    const TypeInfo *type = ResolveType(instance, info[0]);
+    if (!type)
+        return env.Null();
+
+    return Napi::Number::New(env, type->size);
+}
+
+static Napi::Value GetTypeAlign(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+
+    const TypeInfo *type = ResolveType(instance, info[0]);
+    if (!type)
+        return env.Null();
+
+    return Napi::Number::New(env, type->align);
+}
+
+static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+
+    const TypeInfo *type = ResolveType(instance, info[0]);
+    if (!type)
+        return env.Null();
+    if (type->defn.IsEmpty()) {
+        ThrowError<Napi::TypeError>(env, "Definition of type %1 is not available", type->name);
+        return env.Null();
+    }
+
+    return type->defn.Value();
+}
+
 static Span<uint8_t> AllocateAndAlign16(Allocator *alloc, Size size)
 {
     RG_ASSERT(AlignLen(size, 16) == size);
@@ -344,7 +401,7 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
     }
 
     InstanceMemory *mem = AllocateCallMemory(instance);
-    CallData call(env, func, mem, instance->debug);
+    CallData call(env, instance, func, mem);
 
     return call.Run(info);
 }
@@ -404,7 +461,7 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         return env.Null();
 
     InstanceMemory *mem = AllocateCallMemory(instance);
-    CallData call(env, &func, mem, instance->debug);
+    CallData call(env, instance, &func, mem);
 
     return call.Run(info);
 }
@@ -417,10 +474,10 @@ class AsyncCall: public Napi::AsyncWorker {
     bool prepared = false;
 
 public:
-    AsyncCall(Napi::Env env, InstanceMemory *mem, FunctionInfo *func, bool debug,
-              Napi::Function &callback)
+    AsyncCall(Napi::Env env, InstanceData *instance, const FunctionInfo *func,
+              InstanceMemory *mem, Napi::Function &callback)
         : Napi::AsyncWorker(callback), env(env), func(func->Ref()),
-          call(env, func, mem, debug) {}
+          call(env, instance, func, mem) {}
     ~AsyncCall() { func->Unref(); }
 
     bool Prepare(const Napi::CallbackInfo &info) {
@@ -480,7 +537,7 @@ static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
     }
 
     InstanceMemory *mem = AllocateCallMemory(instance);
-    AsyncCall *async = new AsyncCall(env, mem, func, instance->debug, callback);
+    AsyncCall *async = new AsyncCall(env, instance, func, mem, callback);
 
     if (async->Prepare(info) && instance->debug) {
         async->DumpDebug();
@@ -870,6 +927,9 @@ static void SetExports(Napi::Env env, Func func)
     func("handle", Napi::Function::New(env, CreateHandleType));
     func("pointer", Napi::Function::New(env, CreatePointerType));
     func("array", Napi::Function::New(env, CreateArrayType));
+    func("sizeof", Napi::Function::New(env, GetTypeSize));
+    func("alignof", Napi::Function::New(env, GetTypeAlign));
+    func("introspect", Napi::Function::New(env, GetTypeDefinition));
     func("load", Napi::Function::New(env, LoadSharedLibrary));
     func("in", Napi::Function::New(env, MarkIn));
     func("out", Napi::Function::New(env, MarkOut));

package/src/ffi.hh

@@ -70,6 +70,8 @@ struct TypeInfo {
     const char *name;
     napi_type_tag tag;
 
+    Napi::ObjectReference defn;
+
     PrimitiveKind primitive;
     int16_t size;
     int16_t align;
@@ -166,7 +168,6 @@ struct InstanceMemory {
 
     Span<uint8_t> stack;
     Span<uint8_t> heap;
-    IndirectBlockAllocator big_alloc { &mem_alloc };
 
     int depth;
     bool temporary;