koffi 2.8.11 → 2.9.0-beta.1

package/src/koffi/src/abi_x86.cc

@@ -238,6 +238,13 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
                 *(const char16_t **)((param.fast ? fast_ptr : args_ptr)++) = str16;
             } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32;
+                if (!PushString32(value, param.directions, &str32)) [[unlikely]]
+                    return false;
+
+                *(const char32_t **)((param.fast ? fast_ptr : args_ptr)++) = str32;
+            } break;
             case PrimitiveKind::Pointer: {
                 void *ptr;
                 if (!PushPointer(value, param.type, param.directions, &ptr)) [[unlikely]]
@@ -380,6 +387,7 @@ void CallData::Execute(const FunctionInfo *func, void *native)
         case PrimitiveKind::UInt64S:
         case PrimitiveKind::String:
         case PrimitiveKind::String16:
+        case PrimitiveKind::String32:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(G); } break;
 #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
@@ -438,6 +446,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
         case PrimitiveKind::UInt64S: return NewBigInt(env, ReverseBytes(result.u64));
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
+        case PrimitiveKind::String32: return result.ptr ? MakeStringFromUTF32(env, (const char32_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             if (result.ptr) {
@@ -652,6 +661,12 @@ void CallData::Relay(Size idx, uint8_t *, uint8_t *caller_sp, bool switch_stack,
                     param.type->dispose(env, param.type, str16);
                 }
             } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32 = *(const char32_t **)(args_ptr++);
+
+                Napi::Value arg = str32 ? MakeStringFromUTF32(env, str32) : env.Null();
+                arguments.Append(arg);
+            } break;
             case PrimitiveKind::Pointer:
             case PrimitiveKind::Callback: {
                 void *ptr2 = *(void **)(args_ptr++);
@@ -798,6 +813,13 @@ void CallData::Relay(Size idx, uint8_t *, uint8_t *caller_sp, bool switch_stack,
 
             out_reg->eax = (uint32_t)str16;
         } break;
+        case PrimitiveKind::String32: {
+            const char32_t *str32;
+            if (!PushString32(value, 1, &str32)) [[unlikely]]
+                return;
+
+            out_reg->eax = (uint32_t)str32;
+        } break;
         case PrimitiveKind::Pointer: {
             uint8_t *ptr;
 

package/src/koffi/src/call.cc

@@ -234,7 +234,8 @@ Size CallData::PushStringValue(Napi::Value value, const char **out_str)
         status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
         RG_ASSERT(status == napi_ok);
 
-        buf = AllocateSpan<char>(&call_alloc, (Size)len + 1);
+        len++;
+        buf = AllocateSpan<char>(&call_alloc, (Size)len);
 
         status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
         RG_ASSERT(status == napi_ok);
@@ -290,7 +291,7 @@ bool CallData::PushString16(Napi::Value value, int directions, const char16_t **
             type->name = "<temporary>";
 
             type->primitive = PrimitiveKind::Array;
-            type->align = 1;
+            type->align = 2;
             type->size = (int32_t)(len * 2);
             type->ref.type = instance->char16_type;
             type->hint = ArrayHint::String;
@@ -335,7 +336,8 @@ Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
         status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
         RG_ASSERT(status == napi_ok);
 
-        buf = AllocateSpan<char16_t>(&call_alloc, ((Size)len + 1) * 2);
+        len++;
+        buf = AllocateSpan<char16_t>(&call_alloc, (Size)len);
 
         status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
         RG_ASSERT(status == napi_ok);
@@ -347,6 +349,116 @@ Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
     return (Size)len;
 }
 
+bool CallData::PushString32(Napi::Value value, int directions, const char32_t **out_str32)
+{
+    if (value.IsString()) {
+        if (directions & 2) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
+            return false;
+        }
+
+        PushString32Value(value, out_str32);
+        return true;
+    } else if (IsNullOrUndefined(value)) {
+        *out_str32 = nullptr;
+        return true;
+    }  else if (value.IsArray()) {
+        Napi::Array array = value.As<Napi::Array>();
+
+        if (!(directions & 2)) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
+            return false;
+        }
+        if (array.Length() != 1) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
+            return false;
+        }
+
+        value = array[0u];
+
+        if (!value.IsString()) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, array[0u]));
+            return false;
+        }
+
+        Size len = PushString32Value(value, out_str32);
+        if (len < 0) [[unlikely]]
+            return false;
+
+        // Create array type
+        TypeInfo *type;
+        {
+            type = AllocateOne<TypeInfo>(&call_alloc, (int)AllocFlag::Zero);
+
+            type->name = "<temporary>";
+
+            type->primitive = PrimitiveKind::Array;
+            type->align = 4;
+            type->size = (int32_t)(len * 4);
+            type->ref.type = instance->char32_type;
+            type->hint = ArrayHint::String;
+        }
+
+        // Prepare output argument
+        {
+            OutArgument *out = out_arguments.AppendDefault();
+
+            napi_status status = napi_create_reference(env, array, 1, &out->ref);
+            RG_ASSERT(status == napi_ok);
+
+            out->kind = OutArgument::Kind::Array;
+            out->ptr = (const uint8_t *)*out_str32;
+            out->type = type;
+        }
+
+        return true;
+    } else {
+        return PushPointer(value, instance->str32_type, directions, (void **)out_str32);
+    }
+}
+
+Size CallData::PushString32Value(Napi::Value value, const char32_t **out_str32)
+{
+    Span<char32_t> buf;
+
+    Span<const char16_t> buf16;
+    buf16.len = PushString16Value(value, &buf16.ptr);
+    if (buf16.len < 0) [[unlikely]]
+        return -1;
+
+    buf.ptr = (char32_t *)mem->heap.ptr;
+    buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32)) / 4;
+
+    if (buf16.len < buf.len) [[likely]] {
+        mem->heap.ptr += buf16.len * 4;
+        mem->heap.len -= buf16.len * 4;
+    } else {
+        buf = AllocateSpan<char32_t>(&call_alloc, buf16.len);
+    }
+
+    Size j = 0;
+    for (Size i = 0; i < buf16.len; i++) {
+        char32_t uc = buf16[i];
+
+        if (uc >= 0xD800 && uc <= 0xDBFF) {
+            char16_t uc2 = buf16.ptr[++i];
+
+            if (uc2 >= 0xDC00 && uc2 <= 0xDFFF) {
+                uc = ((uc - 0xD800) << 10) + (uc2 - 0xDC00) + 0x10000u;
+            } else {
+                uc = '?';
+            }
+        } else if (uc >= 0xDC00 && uc <= 0xDFFF) {
+            uc = '?';
+        }
+
+        buf[j++] = uc;
+    }
+
+    *out_str32 = buf.ptr;
+    return j;
+}
+
 bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin)
 {
     RG_ASSERT(IsObject(obj));
@@ -566,6 +678,13 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
 
                 *(const char16_t **)dest = str16;
             } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32;
+                if (!PushString32(value, 1, &str32)) [[unlikely]]
+                    return false;
+
+                *(const char32_t **)dest = str32;
+            } break;
             case PrimitiveKind::Pointer: {
                 void *ptr;
                 if (!PushPointer(value, member.type, 1, &ptr)) [[unlikely]]
@@ -795,6 +914,15 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type
                 *(const char16_t **)dest = str16;
             });
         } break;
+        case PrimitiveKind::String32: {
+            PUSH_ARRAY(true, "string", {
+                const char32_t *str32;
+                if (!PushString32(value, 1, &str32)) [[unlikely]]
+                    return false;
+
+                *(const char32_t **)dest = str32;
+            });
+        } break;
         case PrimitiveKind::Pointer: {
             PUSH_ARRAY(true, ref->name, {
                 void *ptr;
@@ -975,7 +1103,8 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
         case napi_external: {
             RG_ASSERT(type->primitive == PrimitiveKind::Pointer ||
                       type->primitive == PrimitiveKind::String ||
-                      type->primitive == PrimitiveKind::String16);
+                      type->primitive == PrimitiveKind::String16 ||
+                      type->primitive == PrimitiveKind::String32);
 
             if (!CheckValueTag(instance, value, type->ref.marker) &&
                     !CheckValueTag(instance, value, instance->void_type) &&
@@ -1002,7 +1131,11 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                         return false;
                     }
 
-                    out_kind = (type->ref.type->size == 2) ? OutArgument::Kind::String16 : OutArgument::Kind::String;
+                    switch (type->ref.type->size) {
+                        default: { out_kind = OutArgument::Kind::String; } break;
+                        case 2: { out_kind = OutArgument::Kind::String16; } break;
+                        case 4: { out_kind = OutArgument::Kind::String32; } break;
+                    }
                     out_max_len = len;
                 } else {
                     if (!type->ref.type->size) [[unlikely]] {
@@ -1089,6 +1222,9 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
             } else if (type->ref.type->primitive == PrimitiveKind::Int16) {
                 PushString16Value(value, (const char16_t **)out_ptr);
                 return true;
+            } else if (type->ref.type->primitive == PrimitiveKind::Int32) {
+                PushString32Value(value, (const char32_t **)out_ptr);
+                return true;
             } else {
                 goto unexpected;
             }
@@ -1152,6 +1288,8 @@ Size CallData::PushIndirectString(Napi::Array array, const TypeInfo *ref, uint8_
         return PushStringValue(value, (const char **)out_ptr);
     } else if (ref->primitive == PrimitiveKind::Int16) {
         return PushString16Value(value, (const char16_t **)out_ptr);
+    } else if (ref->primitive == PrimitiveKind::Int32) {
+        return PushString32Value(value, (const char32_t **)out_ptr);
     } else {
         return -1;
     }
@@ -1267,6 +1405,18 @@ void CallData::PopOutArguments()
                 array.Set(0u, str);
             } break;
 
+            case OutArgument::Kind::String32: {
+                Napi::Array array(env, value);
+
+                RG_ASSERT(array.IsArray());
+                RG_ASSERT(array.Length() == 1);
+
+                Size len = NullTerminatedLength((const char32_t *)out.ptr, out.max_len);
+                Napi::String str = MakeStringFromUTF32(env, (const char32_t *)out.ptr, len);
+
+                array.Set(0u, str);
+            } break;
+
             case OutArgument::Kind::Object: {
                 Napi::Object obj = value.As<Napi::Object>();
 

package/src/koffi/src/call.hh

@@ -42,6 +42,7 @@ class alignas(8) CallData {
             Buffer,
             String,
             String16,
+            String32,
             Object
         };
 
@@ -117,6 +118,8 @@ public:
     Size PushStringValue(Napi::Value value, const char **out_str);
     bool PushString16(Napi::Value value, int directions, const char16_t **out_str16);
     Size PushString16Value(Napi::Value value, const char16_t **out_str16);
+    bool PushString32(Napi::Value value, int directions, const char32_t **out_str32);
+    Size PushString32Value(Napi::Value value, const char32_t **out_str32);
     bool PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin);
     bool PushNormalArray(Napi::Array array, Size len, const TypeInfo *type, uint8_t *origin);
     void PushBuffer(Span<const uint8_t> buffer, Size size, const TypeInfo *type, uint8_t *origin);

package/src/koffi/src/ffi.cc

@@ -46,6 +46,7 @@
         #define MAP_STACK 0
     #endif
 #endif
+#include <wchar.h>
 
 #include <napi.h>
 
@@ -648,7 +649,8 @@ static Napi::Value EncodePointerDirection(const Napi::CallbackInfo &info, int di
 
     if (type->primitive != PrimitiveKind::Pointer &&
             type->primitive != PrimitiveKind::String &&
-            type->primitive != PrimitiveKind::String16) {
+            type->primitive != PrimitiveKind::String16 &&
+            type->primitive != PrimitiveKind::String32) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 type, expected pointer or string type", type->name);
         return env.Null();
     }
@@ -698,7 +700,8 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
         return env.Null();
     if (src->primitive != PrimitiveKind::Pointer &&
             src->primitive != PrimitiveKind::String &&
-            src->primitive != PrimitiveKind::String16) {
+            src->primitive != PrimitiveKind::String16 &&
+            src->primitive != PrimitiveKind::String32) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 type, expected pointer or string type", src->name);
         return env.Null();
     }
@@ -1241,6 +1244,7 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
             case PrimitiveKind::UInt64S:
             case PrimitiveKind::String:
             case PrimitiveKind::String16:
+            case PrimitiveKind::String32:
             case PrimitiveKind::Float32:
             case PrimitiveKind::Float64:
             case PrimitiveKind::Prototype:
@@ -1940,7 +1944,8 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
     if (type->primitive != PrimitiveKind::Pointer &&
             type->primitive != PrimitiveKind::Callback &&
             type->primitive != PrimitiveKind::String &&
-            type->primitive != PrimitiveKind::String16) [[unlikely]] {
+            type->primitive != PrimitiveKind::String16 &&
+            type->primitive != PrimitiveKind::String32) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Only pointer or string types can be used for casting");
         return env.Null();
     }
@@ -2202,7 +2207,10 @@ static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initiali
     if (IsInteger(type) || IsFloat(type)) {
         type->flags |= (int)TypeFlag::HasTypedArray;
     }
-    if (TestStr(type->name, "char") || TestStr(type->name, "char16") || TestStr(type->name, "char16_t")) {
+    if (TestStr(type->name, "char") ||
+            TestStr(type->name, "char16") || TestStr(type->name, "char16_t") ||
+            TestStr(type->name, "char32") || TestStr(type->name, "char32_t") ||
+            TestStr(type->name, "wchar") || TestStr(type->name, "wchar_t")) {
         type->flags |= (int)TypeFlag::IsCharLike;
     }
 
@@ -2359,6 +2367,12 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
         RegisterPrimitiveType(env, types, {"char"}, PrimitiveKind::Int8, 1, 1);
         RegisterPrimitiveType(env, types, {"unsigned char", "uchar"}, PrimitiveKind::UInt8, 1, 1);
         RegisterPrimitiveType(env, types, {"char16_t", "char16"}, PrimitiveKind::Int16, 2, 2);
+        RegisterPrimitiveType(env, types, {"char32_t", "char32"}, PrimitiveKind::Int32, 4, 4);
+        if (RG_SIZE(wchar_t) == 2) {
+            RegisterPrimitiveType(env, types, {"wchar_t", "wchar"}, PrimitiveKind::Int16, 2, 2);
+        } else if (RG_SIZE(wchar_t) == 4) {
+            RegisterPrimitiveType(env, types, {"wchar_t", "wchar"}, PrimitiveKind::Int32, 4, 4);
+        }
         RegisterPrimitiveType(env, types, {"int16_t", "int16"}, PrimitiveKind::Int16, 2, 2);
         RegisterPrimitiveType(env, types, {"int16_le_t", "int16_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int16), 2, 2);
         RegisterPrimitiveType(env, types, {"int16_be_t", "int16_be"}, GetBigEndianPrimitive(PrimitiveKind::Int16), 2, 2);
@@ -2392,12 +2406,20 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
         RegisterPrimitiveType(env, types, {"double", "float64"}, PrimitiveKind::Float64, 8, alignof(double));
         RegisterPrimitiveType(env, types, {"char *", "str", "string"}, PrimitiveKind::String, RG_SIZE(void *), alignof(void *), "char");
         RegisterPrimitiveType(env, types, {"char16_t *", "char16 *", "str16", "string16"}, PrimitiveKind::String16, RG_SIZE(void *), alignof(void *), "char16_t");
+        RegisterPrimitiveType(env, types, {"char32_t *", "char32 *", "str32", "string32"}, PrimitiveKind::String32, RG_SIZE(void *), alignof(void *), "char32_t");
+        if (RG_SIZE(wchar_t) == 2) {
+            RegisterPrimitiveType(env, types, {"wchar_t *", "wchar *"}, PrimitiveKind::String16, RG_SIZE(void *), alignof(void *), "wchar_t");
+        } else if (RG_SIZE(wchar_t) == 4) {
+            RegisterPrimitiveType(env, types, {"wchar_t *", "wchar *"}, PrimitiveKind::String32, RG_SIZE(void *), alignof(void *), "wchar_t");
+        }
 
         instance->void_type = instance->types_map.FindValue("void", nullptr);
         instance->char_type = instance->types_map.FindValue("char", nullptr);
         instance->char16_type = instance->types_map.FindValue("char16", nullptr);
+        instance->char32_type = instance->types_map.FindValue("char32", nullptr);
         instance->str_type = instance->types_map.FindValue("char *", nullptr);
         instance->str16_type = instance->types_map.FindValue("char16_t *", nullptr);
+        instance->str32_type = instance->types_map.FindValue("char32_t *", nullptr);
 
         instance->active_symbol = Napi::Symbol::New(env, "active");
 

package/src/koffi/src/ffi.hh

@@ -60,6 +60,7 @@ enum class PrimitiveKind {
     UInt64S,
     String,
     String16,
+    String32,
     Pointer,
     Record,
     Union,
@@ -88,6 +89,7 @@ static const char *const PrimitiveKindNames[] = {
     "UInt64S",
     "String",
     "String16",
+    "String32",
     "Pointer",
     "Record",
     "Union",
@@ -283,8 +285,10 @@ struct InstanceData {
     const TypeInfo *void_type;
     const TypeInfo *char_type;
     const TypeInfo *char16_type;
+    const TypeInfo *char32_type;
     const TypeInfo *str_type;
     const TypeInfo *str16_type;
+    const TypeInfo *str32_type;
 
     Napi::Symbol active_symbol;
 

package/src/koffi/src/init.js

@@ -0,0 +1,122 @@
+// Copyright 2023 Niels Martignène <niels.martignene@protonmail.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the “Software”), to deal in
+// the Software without restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+// Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+const { get_napi_version, determine_arch } = require('../../cnoke/src/tools.js');
+const pkg = require('../package.json');
+
+function detect() {
+    if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
+        let major = parseInt(process.versions.node, 10);
+        let required = get_napi_version(pkg.cnoke.napi, major);
+
+        if (required != null) {
+            throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} requires Node >= ${required} in the Node ${major}.x branch (N-API >= ${pkg.cnoke.napi})`);
+        } else {
+            throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} does not support the Node ${major}.x branch (N-API < ${pkg.cnoke.napi})`);
+        }
+    }
+
+    let arch = determine_arch();
+    let triplet = `${process.platform}_${arch}`;
+
+    return triplet;
+}
+
+function init(triplet, native) {
+    if (native == null) {
+        let roots = [path.join(__dirname, '..')];
+        let triplets = [triplet];
+
+        if (process.resourcesPath != null)
+            roots.push(process.resourcesPath);
+        if (triplet.startsWith('linux_')) {
+            let musl = triplet.replace(/^linux_/, 'musl_');
+            triplets.push(musl);
+        }
+
+        let filenames = roots.flatMap(root => triplets.flatMap(triplet => [
+            `${root}/build/koffi/${triplet}/koffi.node`,
+            `${root}/koffi/${triplet}/koffi.node`,
+            `${root}/node_modules/koffi/build/koffi/${triplet}/koffi.node`,
+            `${root}/../../bin/Koffi/${triplet}/koffi.node`
+        ]));
+
+        let first_err = null;
+
+        for (let filename of filenames) {
+            if (!fs.existsSync(filename))
+                continue;
+
+            try {
+                // Trick so that webpack does not try to do anything with require() call
+                native = eval('require')(filename);
+            } catch (err) {
+                if (first_err == null)
+                    first_err = err;
+                continue;
+            }
+
+            break;
+        }
+
+        if (first_err != null)
+            throw first_err;
+    }
+
+    if (native == null)
+        throw new Error('Cannot find the native Koffi module; did you bundle it correctly?');
+    if (native.version != pkg.version)
+        throw new Error('Mismatched native Koffi modules');
+
+    let mod = wrap(native);
+    return mod;
+}
+
+function wrap(native) {
+    let obj = {
+        ...native,
+
+        // Deprecated functions
+        handle: util.deprecate(native.opaque, 'The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead', 'KOFFI001'),
+        callback: util.deprecate(native.proto, 'The koffi.callback() function was deprecated in Koffi 2.4, use koffi.proto() instead', 'KOFFI002')
+    };
+
+    obj.load = (...args) => {
+        let lib = native.load(...args);
+
+        lib.cdecl = util.deprecate((...args) => lib.func('__cdecl', ...args), 'The koffi.cdecl() function was deprecated in Koffi 2.7, use koffi.func(...) instead', 'KOFFI003');
+        lib.stdcall = util.deprecate((...args) => lib.func('__stdcall', ...args), 'The koffi.stdcall() function was deprecated in Koffi 2.7, use koffi.func("__stdcall", ...) instead', 'KOFFI004');
+        lib.fastcall = util.deprecate((...args) => lib.func('__fastcall', ...args), 'The koffi.fastcall() function was deprecated in Koffi 2.7, use koffi.func("__fastcall", ...) instead', 'KOFFI005');
+        lib.thiscall = util.deprecate((...args) => lib.func('__thiscall', ...args), 'The koffi.thiscall() function was deprecated in Koffi 2.7, use koffi.func("__thiscall", ...) instead', 'KOFFI006');
+
+        return lib;
+    };
+
+    return obj;
+}
+
+module.exports = {
+    detect,
+    init
+};