koffi 0.9.28 → 0.9.29

package/package.json

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

package/src/ffi.cc

@@ -75,20 +75,20 @@ static const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value val
     }
 }
 
-static Napi::Value CreateStructType(const Napi::CallbackInfo &info)
+static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    if (info.Length() < 2) {
-        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 or 2 arguments, got %1", info.Length());
         return env.Null();
     }
-    if (!info[0].IsString()) {
+    if (info.Length() > 1 && !info[0].IsString()) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
         return env.Null();
     }
-    if (!IsObject(info[1])) {
+    if (!IsObject(info[info.Length() > 1])) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for members, expected object", GetValueType(instance, info[1]));
         return env.Null();
     }
@@ -96,8 +96,8 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info)
     TypeInfo *type = instance->types.AppendDefault();
     RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
-    std::string name = info[0].As<Napi::String>();
-    Napi::Object obj = info[1].As<Napi::Object>();
+    std::string name = info.Length() > 1 ? info[0].As<Napi::String>() : std::string("<anonymous>");
+    Napi::Object obj = info[info.Length() > 1].As<Napi::Object>();
     Napi::Array keys = obj.GetPropertyNames();
 
     type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
@@ -116,8 +116,10 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info)
         if (!member.type)
             return env.Null();
 
-        type->size = (int16_t)(AlignLen(type->size, member.type->align) + member.type->size);
-        type->align = std::max(type->align, member.type->align);
+        member.align = pad ? member.type->align : 1;
+
+        type->size = (int16_t)(AlignLen(type->size, member.align) + member.type->size);
+        type->align = std::max(type->align, member.align);
 
         type->members.Append(member);
     }
@@ -125,7 +127,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info)
     type->size = (int16_t)AlignLen(type->size, type->align);
 
     // If the insert succeeds, we cannot fail anymore
-    if (!instance->types_map.TrySet(type).second) {
+    if (info.Length() > 1 && !instance->types_map.TrySet(type).second) {
         ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
         return env.Null();
     }
@@ -137,6 +139,16 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info)
     return external;
 }
 
+static Napi::Value CreatePaddedStructType(const Napi::CallbackInfo &info)
+{
+    return CreateStructType(info, true);
+}
+
+static Napi::Value CreatePackedStructType(const Napi::CallbackInfo &info)
+{
+    return CreateStructType(info, false);
+}
+
 static Napi::Value CreateHandleType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -564,7 +576,8 @@ InstanceData::InstanceData()
 template <typename Func>
 static void SetExports(Napi::Env env, Func func)
 {
-    func("struct", Napi::Function::New(env, CreateStructType));
+    func("struct", Napi::Function::New(env, CreatePaddedStructType));
+    func("pack", Napi::Function::New(env, CreatePackedStructType));
     func("handle", Napi::Function::New(env, CreateHandleType));
     func("pointer", Napi::Function::New(env, CreatePointerType));
     func("load", Napi::Function::New(env, LoadSharedLibrary));

package/src/ffi.hh

@@ -89,6 +89,7 @@ struct TypeInfo {
 struct RecordMember {
     const char *name;
     const TypeInfo *type;
+    int16_t align;
 };
 
 struct LibraryHolder {

package/src/util.cc

@@ -81,36 +81,32 @@ const char *CallData::PushString(const Napi::Value &value)
 {
     RG_ASSERT(value.IsString());
 
-    const Size SmallSize = 32;
-
     Napi::Env env = value.Env();
-    napi_status status;
 
     Span<char> buf;
     size_t len = 0;
+    napi_status status;
 
-    // Optimize for small strings
-    buf.len = SmallSize;
-    if (RG_UNLIKELY(!AllocHeap(buf.len, 1, &buf.ptr)))
-        return nullptr;
-    if (RG_UNLIKELY(napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len) != napi_ok)) {
-        ThrowError<Napi::Error>(env, "Failed to convert string to UTF-8");
-        return nullptr;
-    }
+    buf.ptr = (char *)heap_mem->ptr;
+    buf.len = std::max((Size)0, heap_mem->len - Kibibytes(32));
+
+    status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
+    RG_ASSERT(status == napi_ok);
 
-    // Slow path for bigger strings
-    if (len >= SmallSize - 1) {
+    len++;
+
+    if (RG_LIKELY(len < (size_t)buf.len)) {
+        heap_mem->ptr += (Size)len;
+        heap_mem->len -= (Size)len;
+    } else {
         status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
         RG_ASSERT(status == napi_ok);
-        RG_ASSERT(len >= SmallSize);
-
-        buf.len = (Size)len + 1;
-        if (RG_UNLIKELY(!AllocHeap(buf.len - SmallSize, 1)))
-            return nullptr;
-        if (RG_UNLIKELY(napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len) != napi_ok)) {
-            ThrowError<Napi::Error>(env, "Failed to convert string to UTF-8");
-            return nullptr;
-        }
+
+        buf.ptr = (char *)Allocator::Allocate(&big_alloc, (Size)len);
+        buf.len = (Size)len;
+
+        status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
+        RG_ASSERT(status == napi_ok);
     }
 
     return buf.ptr;
@@ -132,7 +128,7 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
             return false;
         }
 
-        dest = AlignUp(dest, member.type->align);
+        dest = AlignUp(dest, member.align);
 
         switch (member.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
@@ -229,7 +225,7 @@ void PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type)
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
 
     for (const RecordMember &member: type->members) {
-        ptr = AlignUp(ptr, member.type->align);
+        ptr = AlignUp(ptr, member.align);
 
         switch (member.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;

package/src/util.hh

@@ -74,6 +74,7 @@ class CallData {
 
     Span<uint8_t> *stack_mem;
     Span<uint8_t> *heap_mem;
+    BlockAllocator big_alloc;
 
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;

package/test/tests/misc.c

@@ -53,6 +53,19 @@ typedef struct BFG {
         double g;
     } inner;
 } BFG;
+#pragma pack(push, 1)
+typedef struct PackedBFG {
+    int8_t a;
+    int64_t b;
+    signed char c;
+    const char *d;
+    short e;
+    struct {
+        float f;
+        double g;
+    } inner;
+} PackedBFG;
+#pragma pack(pop)
 
 EXPORT void FillPack3(int a, int b, int c, Pack3 *p)
 {
@@ -135,14 +148,36 @@ EXPORT const char *ConcatenateToStr8(int64_t a, int64_t b, int64_t c, int64_t d,
     return buf;
 }
 
-EXPORT BFG STDCALL MakeBFG(int x, double y, BFG *p)
+EXPORT BFG STDCALL MakeBFG(BFG *p, int x, double y, const char *str)
 {
     BFG bfg;
 
+    char buf[64];
+    snprintf(buf, sizeof(buf), "X/%s/X", str);
+
+    bfg.a = x;
+    bfg.b = x * 2;
+    bfg.c = x - 27;
+    bfg.d = buf;
+    bfg.e = x * 27;
+    bfg.inner.f = (float)y * x;
+    bfg.inner.g = (double)y - x;
+    *p = bfg;
+
+    return bfg;
+}
+
+EXPORT PackedBFG FASTCALL MakePackedBFG(int x, double y, PackedBFG *p, const char *str)
+{
+    PackedBFG bfg;
+
+    char buf[64];
+    snprintf(buf, sizeof(buf), "X/%s/X", str);
+
     bfg.a = x;
     bfg.b = x * 2;
     bfg.c = x - 27;
-    bfg.d = "Hello";
+    bfg.d = buf;
     bfg.e = x * 27;
     bfg.inner.f = (float)y * x;
     bfg.inner.g = (double)y - x;
@@ -150,3 +185,13 @@ EXPORT BFG STDCALL MakeBFG(int x, double y, BFG *p)
 
     return bfg;
 }
+
+EXPORT const char *ReturnBigString(const char *str)
+{
+    static char buf[1 * 1024 * 1024];
+
+    size_t len = strlen(str);
+    memcpy(buf, str, len + 1);
+
+    return buf;
+}

package/test/tests/misc.js

@@ -29,7 +29,18 @@ const BFG = koffi.struct('BFG', {
     c: 'char',
     d: 'string',
     e: 'short',
-    inner: koffi.struct('BFG.inner', {
+    inner: koffi.struct({
+        f: 'float',
+        g: 'double'
+    })
+});
+const PackedBFG = koffi.pack('PackedBFG', {
+    a: 'int8_t',
+    b: 'int64_t',
+    c: 'char',
+    d: 'string',
+    e: 'short',
+    inner: koffi.pack({
         f: 'float',
         g: 'double'
     })
@@ -60,28 +71,53 @@ async function test() {
     const ConcatenateToStr1 = lib.cdecl('ConcatenateToStr1', 'string', [...Array(8).fill('int8_t'), koffi.struct('IJK1', {i: 'int8_t', j: 'int8_t', k: 'int8_t'}), 'int8_t']);
     const ConcatenateToStr4 = lib.cdecl('ConcatenateToStr4', 'string', [...Array(8).fill('int32_t'), koffi.pointer(koffi.struct('IJK4', {i: 'int32_t', j: 'int32_t', k: 'int32_t'})), 'int32_t']);
     const ConcatenateToStr8 = lib.cdecl('ConcatenateToStr8', 'string', [...Array(8).fill('int64_t'), koffi.struct('IJK8', {i: 'int64_t', j: 'int64_t', k: 'int64_t'}), 'int64_t']);
-    const MakeBFG = lib.stdcall('MakeBFG', BFG, ['int', 'double', koffi.out(koffi.pointer(BFG))]);
+    const MakeBFG = lib.stdcall('MakeBFG', BFG, [koffi.out(koffi.pointer(BFG)), 'int', 'double', 'string']);
+    const MakePackedBFG = lib.stdcall('MakePackedBFG', PackedBFG, ['int', 'double', koffi.out(koffi.pointer(PackedBFG)), 'string']);
+    const ReturnBigString = lib.stdcall('ReturnBigString', 'string', ['string']);
+
+    // Simple tests
+    {
+        let p = {};
 
-    let p = {};
+        FillPack3(1, 2, 3, p);
+        assert.deepEqual(p, { a: 1, b: 2, c: 3 });
 
-    FillPack3(1, 2, 3, p);
-    assert.deepEqual(p, { a: 1, b: 2, c: 3 });
+        let q = RetPack3(6, 9, -12);
+        assert.deepEqual(q, { a: 6, b: 9, c: -12 });
+
+        AddPack3(6, 9, -12, p);
+        assert.deepEqual(p, { a: 7, b: 11, c: -9 });
+    }
 
-    let q = RetPack3(6, 9, -12);
-    assert.deepEqual(q, { a: 6, b: 9, c: -12 });
+    // Many parameters
+    {
+        assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
+        assert.equal(ConcatenateToInt4(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
+        assert.equal(ConcatenateToInt8(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
+        assert.equal(ConcatenateToStr1(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
+        assert.equal(ConcatenateToStr4(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
+        assert.equal(ConcatenateToStr8(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
+    }
 
-    AddPack3(6, 9, -12, p);
-    assert.deepEqual(p, { a: 7, b: 11, c: -9 });
+    // Big struct
+    {
+        let out = {};
+        let bfg = MakeBFG(out, 2, 7, '__Hello123456789++++foobarFOOBAR!__');
+        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/__Hello123456789++++foobarFOOBAR!__/X', e: 54, inner: { f: 14, g: 5 } });
+        assert.deepEqual(out, bfg);
+    }
 
-    assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-    assert.equal(ConcatenateToInt4(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-    assert.equal(ConcatenateToInt8(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-    assert.equal(ConcatenateToStr1(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
-    assert.equal(ConcatenateToStr4(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
-    assert.equal(ConcatenateToStr8(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
+    // Packed struct
+    {
+        let out = {};
+        let bfg = MakePackedBFG(2, 7, out, '__Hello123456789++++foobarFOOBAR!__');
+        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/__Hello123456789++++foobarFOOBAR!__/X', e: 54, inner: { f: 14, g: 5 } });
+        assert.deepEqual(out, bfg);
+    }
 
-    let out = {};
-    let bfg = MakeBFG(2, 7, out);
-    assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'Hello', e: 54, inner: { f: 14, g: 5 } });
-    assert.deepEqual(out, bfg);
+    // Big string
+    {
+        let str = 'fooBAR!'.repeat(1024 * 1024);
+        assert.equal(ReturnBigString(str), str);
+    }
 }