koffi 2.3.12 → 2.3.13

package/CHANGELOG.md

@@ -4,6 +4,12 @@
 
 ### Koffi 2.3
 
+#### Koffi 2.3.13
+
+**Main changes:**
+
+- Add `koffi.address()` to get the raw value of a wrapper pointer
+
 #### Koffi 2.3.12
 
 **Main fixes:**

package/doc/pointers.md

@@ -133,3 +133,7 @@ By default, just like for objects, array arguments are copied from JS to C but n
 Disposable types allow you to register a function that will automatically called after each C to JS conversion performed by Koffi. This can be used to avoid leaking heap-allocated strings, for example.
 
 Read the documentation for [disposable types](calls.md#heap-allocated-values) on the page about function calls.
+
+## Unwrap pointers
+
+You can use `koffi.address(ptr)` on a pointer to get the numeric value as a [BigInt object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt).

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "koffi",
-    "version": "2.3.12",
-    "stable": "2.3.12",
+    "version": "2.3.13",
+    "stable": "2.3.13",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",

package/src/index.d.ts

@@ -101,8 +101,6 @@ declare module 'koffi' {
     export function out(value: TypeSpec): IKoffiCType;
     export function inout(value: TypeSpec): IKoffiCType;
 
-    export function as(value: any, type: TypeSpec): IKoffiPointerCast;
-
     export function disposable(type: TypeSpec): IKoffiCType;
     export function disposable(name: string, type: TypeSpec): IKoffiCType;
     export function disposable(name: string, type: TypeSpec, freeFunction: Function): IKoffiCType;
@@ -114,10 +112,12 @@ declare module 'koffi' {
     export function register(thisValue: any, callback: Function, type: TypeSpec): IKoffiRegisteredCallback;
     export function unregister(callback: IKoffiRegisteredCallback): void;
 
+    export function as(value: any, type: TypeSpec): IKoffiPointerCast;
     export function decode(value: any, type: TypeSpec): any;
     export function decode(value: any, type: TypeSpec, len: number): any;
     export function decode(value: any, offset: number, type: TypeSpec): any;
     export function decode(value: any, offset: number, type: TypeSpec, len: number): any;
+    export function address(value: any): bigint;
 
     export function sizeof(type: TypeSpec): number;
     export function alignof(type: TypeSpec): number;

package/src/koffi/src/ffi.cc

@@ -722,19 +722,30 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     return WrapType(env, instance, type);
 }
 
+static inline bool CheckExternalPointer(Napi::Env env, Napi::Value value)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (!value.IsExternal() || CheckValueTag(instance, value, &TypeInfoMarker) ||
+                               CheckValueTag(instance, value, &CastMarker) ||
+                               CheckValueTag(instance, value, &MagicUnionMarker)) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected external pointer", GetValueType(instance, value));
+        return false;
+    }
+
+    return true;
+}
+
 static Napi::Value CallFree(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();
     }
-    if (!info[0].IsExternal() || CheckValueTag(instance, info[0], &TypeInfoMarker)) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected external", GetValueType(instance, info[0]));
+    if (!CheckExternalPointer(env, info[0]))
         return env.Null();
-    }
 
     Napi::External<void> external = info[0].As<Napi::External<void>>();
     void *ptr = external.Data();
@@ -1973,6 +1984,26 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
     return ret;
 }
 
+static Napi::Value GetPointerAddress(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+    if (!CheckExternalPointer(env, info[0]))
+        return env.Null();
+
+    Napi::External<void> external = info[0].As<Napi::External<void>>();
+    void *ptr = external.Data();
+
+    uint64_t ptr64 = (uint64_t)(uintptr_t)ptr;
+    Napi::BigInt bigint = Napi::BigInt::New(env, ptr64);
+
+    return bigint;
+}
+
 extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
     if (RG_LIKELY(exec_call)) {
@@ -2038,6 +2069,7 @@ static void SetExports(Napi::Env env, Func func)
 
     func("as", Napi::Function::New(env, CastValue));
     func("decode", Napi::Function::New(env, DecodeValue));
+    func("address", Napi::Function::New(env, GetPointerAddress));
 
 #if defined(_WIN32)
     func("extension", Napi::String::New(env, ".dll"));