koffi 1.1.0-beta.2 → 1.1.0-beta.5

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.2",
+  "version": "1.1.0-beta.5",
   "description": "Fast and simple FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",

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);
@@ -539,8 +596,9 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
         param.type = ResolveType(instance, parameters[j], &param.directions);
         if (!param.type)
             return false;
-        if (param.type->primitive == PrimitiveKind::Void) {
-            ThrowError<Napi::TypeError>(env, "Type void cannot be used as a parameter");
+        if (param.type->primitive == PrimitiveKind::Void ||
+                param.type->primitive == PrimitiveKind::Array) {
+            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", param.type->name);
             return false;
         }
 
@@ -869,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;

package/src/parser.cc

@@ -36,7 +36,7 @@ bool PrototypeParser::Parse(Napi::String proto, FunctionInfo *func)
 
     func->ret.type = ParseType();
     if (func->ret.type->primitive == PrimitiveKind::Array) {
-        MarkError("You are not allowed to directly return fixed-size arrays");
+        MarkError("You are not allowed to directly return C arrays");
         return false;
     }
     if (Match("__cdecl")) {
@@ -69,8 +69,9 @@ bool PrototypeParser::Parse(Napi::String proto, FunctionInfo *func)
             }
 
             param.type = ParseType();
-            if (param.type->primitive == PrimitiveKind::Void) {
-                MarkError("Type void cannot be used as a parameter");
+            if (param.type->primitive == PrimitiveKind::Void ||
+                    param.type->primitive == PrimitiveKind::Array) {
+                MarkError("Type %1 cannot be used as a parameter", param.type->name);
                 return false;
             }