koffi 1.0.1 → 1.0.2

package/src/util.cc

@@ -56,6 +56,13 @@ const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value value, int
 
 const TypeInfo *GetPointerType(InstanceData *instance, const TypeInfo *ref)
 {
+    // Special cases
+    if (TestStr(ref->name, "char")) {
+        return instance->types_map.FindValue("string", nullptr);
+    } else if (TestStr(ref->name, "char16") || TestStr(ref->name, "char16_t")) {
+        return instance->types_map.FindValue("string16", nullptr);
+    }
+
     char name_buf[256];
     Fmt(name_buf, "%1%2*", ref->name, ref->primitive == PrimitiveKind::Pointer ? "" : " ");
 
@@ -119,163 +126,6 @@ bool CheckValueTag(const InstanceData *instance, Napi::Value value, const void *
     return match;
 }
 
-CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func)
-    : env(env), instance(instance), func(func),
-      stack_mem(&instance->stack_mem), heap_mem(&instance->heap_mem),
-      old_stack_mem(instance->stack_mem), old_heap_mem(instance->heap_mem)
-{
-    RG_ASSERT(AlignUp(stack_mem->ptr, 16) == stack_mem->ptr);
-    RG_ASSERT(AlignUp(stack_mem->end(), 16) == stack_mem->end());
-}
-
-CallData::~CallData()
-{
-    instance->stack_mem = old_stack_mem;
-    instance->heap_mem = old_heap_mem;
-}
-
-const char *CallData::PushString(const Napi::Value &value)
-{
-    RG_ASSERT(value.IsString());
-
-    Napi::Env env = value.Env();
-
-    Span<char> buf;
-    size_t len = 0;
-    napi_status status;
-
-    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);
-
-    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);
-
-        len++;
-
-        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;
-}
-
-bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest)
-{
-    Napi::Env env = obj.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-    RG_ASSERT(IsObject(obj));
-    RG_ASSERT(type->primitive == PrimitiveKind::Record);
-
-    for (const RecordMember &member: type->members) {
-        Napi::Value value = obj.Get(member.name);
-
-        if (RG_UNLIKELY(value.IsUndefined())) {
-            ThrowError<Napi::TypeError>(env, "Missing expected object property '%1'", member.name);
-            return false;
-        }
-
-        dest = AlignUp(dest, member.align);
-
-        switch (member.type->primitive) {
-            case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
-
-            case PrimitiveKind::Bool: {
-                if (RG_UNLIKELY(!value.IsBoolean())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected boolean", GetValueType(instance, value), member.name);
-                    return false;
-                }
-
-                bool b = value.As<Napi::Boolean>();
-                *(bool *)dest = b;
-            } break;
-
-            case PrimitiveKind::Int8:
-            case PrimitiveKind::UInt8:
-            case PrimitiveKind::Int16:
-            case PrimitiveKind::UInt16:
-            case PrimitiveKind::Int32:
-            case PrimitiveKind::UInt32:
-            case PrimitiveKind::Int64:
-            case PrimitiveKind::UInt64: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
-                    return false;
-                }
-
-                int64_t v = CopyNumber<int64_t>(value);
-                memcpy(dest, &v, member.type->size); // Little Endian
-            } break;
-            case PrimitiveKind::Float32: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
-                    return false;
-                }
-
-                float f = CopyNumber<float>(value);
-                memcpy(dest, &f, 4);
-            } break;
-            case PrimitiveKind::Float64: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
-                    return false;
-                }
-
-                double d = CopyNumber<double>(value);
-                memcpy(dest, &d, 8);
-            } break;
-            case PrimitiveKind::String: {
-                if (RG_UNLIKELY(!value.IsString())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected string", GetValueType(instance, value), member.name);
-                    return false;
-                }
-
-                const char *str = PushString(value);
-                if (RG_UNLIKELY(!str))
-                    return false;
-                *(const char **)dest = str;
-            } break;
-            case PrimitiveKind::Pointer: {
-                if (RG_UNLIKELY(!CheckValueTag(instance, value, member.type))) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected %3", GetValueType(instance, value), member.name, member.type->name);
-                    return false;
-                }
-
-                Napi::External external = value.As<Napi::External<void>>();
-                void *ptr = external.Data();
-                *(void **)dest = ptr;
-            } break;
-
-            case PrimitiveKind::Record: {
-                if (RG_UNLIKELY(!IsObject(value))) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected object", GetValueType(instance, value), member.name);
-                    return false;
-                }
-
-                Napi::Object obj = value.As<Napi::Object>();
-                if (!PushObject(obj, member.type, dest))
-                    return false;
-            } break;
-        }
-
-        dest += member.type->size;
-    }
-
-    return true;
-}
-
 void PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type)
 {
     Napi::Env env = obj.Env();
@@ -339,6 +189,10 @@ void PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type)
                 const char *str = *(const char **)ptr;
                 obj.Set(member.name, Napi::String::New(env, str));
             } break;
+            case PrimitiveKind::String16: {
+                const char16_t *str16 = *(const char16_t **)ptr;
+                obj.Set(member.name, Napi::String::New(env, str16));
+            } break;
             case PrimitiveKind::Pointer: {
                 void *ptr2 = *(void **)ptr;
 

package/src/util.hh

@@ -72,97 +72,6 @@ static inline bool IsObject(Napi::Value value)
     return value.IsObject() && !IsNullOrUndefined(value) && !value.IsArray();
 }
 
-class CallData {
-    Napi::Env env;
-    InstanceData *instance;
-    const FunctionInfo *func;
-
-    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;
-
-public:
-    CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func);
-    ~CallData();
-
-    Span<uint8_t> GetStack() const
-    {
-        uint8_t *sp = stack_mem->end();
-        Size len = old_stack_mem.end() - sp;
-
-        return MakeSpan(sp, len);
-    }
-    uint8_t *GetSP() const { return stack_mem->end(); };
-
-    Span<uint8_t> GetHeap() const
-    {
-        uint8_t *ptr = old_heap_mem.ptr;
-        Size len = heap_mem->ptr - ptr;
-
-        return MakeSpan(ptr, len);
-    }
-
-    template <typename T = void>
-    bool AllocStack(Size size, Size align, T **out_ptr = nullptr);
-    template <typename T = void>
-    bool AllocHeap(Size size, Size align, T **out_ptr = nullptr);
-
-    const char *PushString(const Napi::Value &value);
-    bool PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest);
-
-    void DumpDebug() const;
-};
-
-template <typename T>
-bool CallData::AllocStack(Size size, Size align, T **out_ptr)
-{
-    uint8_t *ptr = AlignDown(stack_mem->end() - size, align);
-    Size delta = stack_mem->end() - ptr;
-
-    if (RG_UNLIKELY(stack_mem->len < delta)) {
-        ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
-        return false;
-    }
-
-    if (instance->debug) {
-        memset(ptr, 0, delta);
-    }
-
-    stack_mem->len -= delta;
-
-    if (out_ptr) {
-        *out_ptr = (T *)ptr;
-    }
-    return true;
-}
-
-template <typename T>
-bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
-{
-    uint8_t *ptr = AlignUp(heap_mem->ptr, align);
-    Size delta = size + (ptr - heap_mem->ptr);
-
-    if (RG_UNLIKELY(delta > heap_mem->len)) {
-        ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
-        return false;
-    }
-
-    if (instance->debug) {
-        memset(heap_mem->ptr, 0, (size_t)delta);
-    }
-
-    heap_mem->ptr += delta;
-    heap_mem->len -= delta;
-
-    if (out_ptr) {
-        *out_ptr = (T *)ptr;
-    }
-    return true;
-}
-
 template <typename T>
 T CopyNumber(const Napi::Value &value)
 {

package/test/CMakeLists.txt

@@ -112,4 +112,5 @@ set_target_properties(misc PROPERTIES PREFIX "")
 
 if(MSVC)
     target_compile_options(misc PRIVATE /wd4116)
+    target_link_options(misc PRIVATE "/DEF:${CMAKE_CURRENT_SOURCE_DIR}/misc.def")
 endif()

package/test/misc.c

@@ -0,0 +1,289 @@
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include <string.h>
+#include <stdarg.h>
+#if __has_include(<uchar.h>)
+    #include <uchar.h>
+#else
+    typedef uint16_t char16_t;
+    typedef uint32_t char32_t;
+#endif
+
+#ifdef _WIN32
+    #define EXPORT __declspec(dllexport)
+#else
+    #define EXPORT __attribute__((visibility("default")))
+#endif
+#if defined(_M_IX86) || defined(__i386__)
+    #ifdef _MSC_VER
+        #define FASTCALL __fastcall
+        #define STDCALL __stdcall
+    #else
+        #define FASTCALL __attribute__((fastcall))
+        #define STDCALL __attribute__((stdcall))
+    #endif
+#else
+    #define FASTCALL
+    #define STDCALL
+#endif
+
+typedef struct Pack1 {
+    int a;
+} Pack1;
+typedef struct Pack2 {
+    int a;
+    int b;
+} Pack2;
+typedef struct Pack3 {
+    int a;
+    int b;
+    int c;
+} Pack3;
+
+typedef struct IJK1 { int8_t i; int8_t j; int8_t k; } IJK1;
+typedef struct IJK4 { int32_t i; int32_t j; int32_t k; } IJK4;
+typedef struct IJK8 { int64_t i; int64_t j; int64_t k; } IJK8;
+
+typedef struct BFG {
+    int8_t a;
+    int64_t b;
+    signed char c;
+    const char *d;
+    short e;
+    struct {
+        float f;
+        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 FillPack1(int a, Pack1 *p)
+{
+    p->a = a;
+}
+
+EXPORT Pack1 RetPack1(int a)
+{
+    Pack1 p;
+
+    p.a = a;
+
+    return p;
+}
+
+EXPORT void FASTCALL AddPack1(int a, Pack1 *p)
+{
+    p->a += a;
+}
+
+EXPORT void FillPack2(int a, int b, Pack2 *p)
+{
+    p->a = a;
+    p->b = b;
+}
+
+EXPORT Pack2 RetPack2(int a, int b)
+{
+    Pack2 p;
+
+    p.a = a;
+    p.b = b;
+
+    return p;
+}
+
+EXPORT void FASTCALL AddPack2(int a, int b, Pack2 *p)
+{
+    p->a += a;
+    p->b += b;
+}
+
+EXPORT void FillPack3(int a, int b, int c, Pack3 *p)
+{
+    p->a = a;
+    p->b = b;
+    p->c = c;
+}
+
+EXPORT Pack3 RetPack3(int a, int b, int c)
+{
+    Pack3 p;
+
+    p.a = a;
+    p.b = b;
+    p.c = c;
+
+    return p;
+}
+
+EXPORT void FASTCALL AddPack3(int a, int b, int c, Pack3 *p)
+{
+    p->a += a;
+    p->b += b;
+    p->c += c;
+}
+
+EXPORT int64_t ConcatenateToInt1(int8_t a, int8_t b, int8_t c, int8_t d, int8_t e, int8_t f,
+                                 int8_t g, int8_t h, int8_t i, int8_t j, int8_t k, int8_t l)
+{
+    int64_t ret = 100000000000ull * a + 10000000000ull * b + 1000000000ull * c +
+                  100000000ull * d + 10000000ull * e + 1000000ull * f +
+                  100000ull * g + 10000ull * h + 1000ull * i +
+                  100ull * j + 10ull * k + 1ull * l;
+    return ret;
+}
+
+EXPORT int64_t ConcatenateToInt4(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f,
+                                 int32_t g, int32_t h, int32_t i, int32_t j, int32_t k, int32_t l)
+{
+    int64_t ret = 100000000000ull * a + 10000000000ull * b + 1000000000ull * c +
+                  100000000ull * d + 10000000ull * e + 1000000ull * f +
+                  100000ull * g + 10000ull * h + 1000ull * i +
+                  100ull * j + 10ull * k + 1ull * l;
+    return ret;
+}
+
+EXPORT int64_t ConcatenateToInt8(int64_t a, int64_t b, int64_t c, int64_t d, int64_t e, int64_t f,
+                                 int64_t g, int64_t h, int64_t i, int64_t j, int64_t k, int64_t l)
+{
+    int64_t ret = 100000000000ull * a + 10000000000ull * b + 1000000000ull * c +
+                  100000000ull * d + 10000000ull * e + 1000000ull * f +
+                  100000ull * g + 10000ull * h + 1000ull * i +
+                  100ull * j + 10ull * k + 1ull * l;
+    return ret;
+}
+
+EXPORT const char *ConcatenateToStr1(int8_t a, int8_t b, int8_t c, int8_t d, int8_t e, int8_t f,
+                                     int8_t g, int8_t h, IJK1 ijk, int8_t l)
+{
+    static char buf[128];
+    snprintf(buf, sizeof(buf), "%d%d%d%d%d%d%d%d%d%d%d%d", a, b, c, d, e, f, g, h, ijk.i, ijk.j, ijk.k, l);
+    return buf;
+}
+
+EXPORT const char *ConcatenateToStr4(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f,
+                                     int32_t g, int32_t h, IJK4 *ijk, int32_t l)
+{
+    static char buf[128];
+    snprintf(buf, sizeof(buf), "%d%d%d%d%d%d%d%d%d%d%d%d", a, b, c, d, e, f, g, h, ijk->i, ijk->j, ijk->k, l);
+    return buf;
+}
+
+EXPORT const char *ConcatenateToStr8(int64_t a, int64_t b, int64_t c, int64_t d, int64_t e, int64_t f,
+                                     int64_t g, int64_t h, IJK8 ijk, int64_t l)
+{
+    static char buf[128];
+    snprintf(buf, sizeof(buf), "%" PRIi64 "%" PRIi64 "%" PRIi64 "%" PRIi64 "%" PRIi64 "%" PRIi64
+                               "%" PRIi64 "%" PRIi64 "%" PRIi64 "%" PRIi64 "%" PRIi64 "%" PRIi64,
+             a, b, c, d, e, f, g, h, ijk.i, ijk.j, ijk.k, l);
+    return buf;
+}
+
+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 = buf;
+    bfg.e = x * 27;
+    bfg.inner.f = (float)y * x;
+    bfg.inner.g = (double)y - x;
+    *p = bfg;
+
+    return bfg;
+}
+
+EXPORT const char *ReturnBigString(const char *str)
+{
+    static char buf[16 * 1024 * 1024];
+
+    size_t len = strlen(str);
+    memcpy(buf, str, len + 1);
+
+    return buf;
+}
+
+EXPORT const char *PrintFmt(const char *fmt, ...)
+{
+    static char buf[256];
+
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(buf, sizeof(buf), fmt, ap);
+    va_end(ap);
+
+    return buf;
+}
+
+size_t Length16(const char16_t *str)
+{
+    size_t len = 0;
+    while (str[len]) {
+        len++;
+    }
+    return len;
+}
+
+EXPORT const char16_t *Concat16(const char16_t *str1, const char16_t *str2)
+{
+    static char16_t buf[1024];
+
+    size_t len1 = Length16(str1);
+    size_t len2 = Length16(str2);
+
+    memcpy(buf, str1, len1 * 2);
+    memcpy(buf + len1, str2, len2 * 2);
+    buf[(len1 + len2) * 2] = 0;
+
+    return buf;
+}

package/test/misc.def

@@ -0,0 +1,3 @@
+LIBRARY MISC
+EXPORTS
+    ReturnBigString @1