koffi 2.5.10 → 2.5.11

package/CHANGELOG.md

@@ -4,6 +4,11 @@
 
 ### Koffi 2.5
 
+#### Koffi 2.5.11
+
+- Support casting function pointers with [koffi.as()](parameters.md#input-polymorphism)
+- Build in C++20 mode
+
 #### Koffi 2.5.10
 
 - Fix CMake regression when client has to build Koffi

package/package.json

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

package/src/core/libcc/libcc.cc

@@ -801,6 +801,108 @@ bool ParseBool(Span<const char> str, bool *out_value, unsigned int flags,
     return false;
 }
 
+bool ParseSize(Span<const char> str, int64_t *out_size, unsigned int flags, Span<const char> *out_remaining)
+{
+    uint64_t size = 0;
+
+    if (!ParseInt(str, &size, flags & ~(int)ParseFlag::End, &str))
+        return false;
+    if (size > INT64_MAX) [[unlikely]]
+        goto overflow;
+
+    if (str.len) {
+        uint64_t multiplier = 1;
+        int next = 1;
+
+        switch (str[0]) {
+            case 'B': { multiplier = 1; } break;
+            case 'k': { multiplier = 1000; } break;
+            case 'M': { multiplier = 1000000; } break;
+            case 'G': { multiplier = 1000000000; } break;
+            case 'T': { multiplier = 1000000000000; } break;
+            default: { next = 0; } break;
+        }
+
+        if ((flags & (int)ParseFlag::End) && str.len > next) [[unlikely]] {
+            if (flags & (int)ParseFlag::Log) {
+                LogError("Unknown size unit '%1'", str[0]);
+            }
+            return false;
+        }
+        str = str.Take(next, str.len - next);
+
+        uint64_t total = size * multiplier;
+        if ((size && total / size != multiplier) || total > INT64_MAX) [[unlikely]]
+            goto overflow;
+        size = total;
+    }
+
+    *out_size = (int64_t)size;
+    if (out_remaining) {
+        *out_remaining = str;
+    }
+    return true;
+
+overflow:
+    if (flags & (int)ParseFlag::Log) {
+        LogError("Size value is too high");
+    }
+    return false;
+}
+
+bool ParseDuration(Span<const char> str, int64_t *out_duration, unsigned int flags, Span<const char> *out_remaining)
+{
+    uint64_t duration = 0;
+
+    if (!ParseInt(str, &duration, flags & ~(int)ParseFlag::End, &str))
+        return false;
+    if (duration > INT64_MAX) [[unlikely]]
+        goto overflow;
+
+    if (str.len) {
+        uint64_t multiplier = 1;
+        int next = 1;
+
+        switch (str[0]) {
+            case 's': { multiplier = 1000; } break;
+            case 'm': { multiplier = 60000; } break;
+            case 'h': { multiplier = 3600000; } break;
+            case 'd': { multiplier = 86400000; } break;
+            default: { next = 0; } break;
+        }
+
+        if ((flags & (int)ParseFlag::End) && str.len > next) [[unlikely]] {
+            if (flags & (int)ParseFlag::Log) {
+                LogError("Unknown duration unit '%1'", str[0]);
+            }
+            return false;
+        }
+        str = str.Take(next, str.len - next);
+
+        uint64_t total = duration * multiplier;
+        if ((duration && total / duration != multiplier) || total > INT64_MAX) [[unlikely]]
+            goto overflow;
+        duration = total;
+    } else {
+        uint64_t total = duration * 1000;
+        if ((duration && total / duration != 1000) || total > INT64_MAX) [[unlikely]]
+            goto overflow;
+        duration = total;
+    }
+
+    *out_duration = (int64_t)duration;
+    if (out_remaining) {
+        *out_remaining = str;
+    }
+    return true;
+
+overflow:
+    if (flags & (int)ParseFlag::Log) {
+        LogError("Duration value is too high");
+    }
+    return false;
+}
+
 // ------------------------------------------------------------------------
 // Format
 // ------------------------------------------------------------------------
@@ -6760,6 +6862,16 @@ bool SpliceStream(StreamReader *reader, int64_t max_len, StreamWriter *writer)
     return true;
 }
 
+bool IsCompressorAvailable(CompressionType compression_type)
+{
+    return CompressorFunctions[(int)compression_type];
+}
+
+bool IsDecompressorAvailable(CompressionType compression_type)
+{
+    return DecompressorFunctions[(int)compression_type];
+}
+
 // ------------------------------------------------------------------------
 // INI
 // ------------------------------------------------------------------------

package/src/core/libcc/libcc.hh

@@ -3315,41 +3315,38 @@ static inline int CmpStr(const char *str1, Span<const char> str2)
 static inline int CmpStr(const char *str1, const char *str2)
     { return strcmp(str1, str2); }
 
-static inline Size StartsWith(Span<const char> str, Span<const char> prefix)
+static inline bool StartsWith(Span<const char> str, Span<const char> prefix)
 {
     Size i = 0;
     while (i < str.len && i < prefix.len) {
         if (str[i] != prefix[i])
-            return 0;
-
+            return false;
         i++;
     }
 
-    return (i == prefix.len) ? i : 0;
+    return (i == prefix.len);
 }
-static inline Size StartsWith(Span<const char> str, const char *prefix)
+static inline bool StartsWith(Span<const char> str, const char *prefix)
 {
     Size i = 0;
     while (i < str.len && prefix[i]) {
         if (str[i] != prefix[i])
-            return 0;
-
+            return false;
         i++;
     }
 
-    return !prefix[i] ? i : 0;
+    return !prefix[i];
 }
-static inline Size StartsWith(const char *str, const char *prefix)
+static inline bool StartsWith(const char *str, const char *prefix)
 {
     Size i = 0;
     while (str[i] && prefix[i]) {
         if (str[i] != prefix[i])
-            return 0;
-
+            return false;
         i++;
     }
 
-    return !prefix[i] ? i : 0;
+    return !prefix[i];
 }
 
 static inline bool EndsWith(Span<const char> str, const char *suffix)
@@ -3703,6 +3700,31 @@ overflow:
 bool ParseBool(Span<const char> str, bool *out_value, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
                Span<const char> *out_remaining = nullptr);
 
+bool ParseSize(Span<const char> str, int64_t *out_size, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
+               Span<const char> *out_remaining = nullptr);
+#if RG_SIZE_MAX < INT64_MAX
+static inline bool ParseSize(Span<const char> str, Size *out_size,
+                             unsigned int flags = RG_DEFAULT_PARSE_FLAGS, Span<const char> *out_remaining = nullptr)
+{
+    int64_t size = 0;
+    if (!ParseSize(str, &size, flags, out_remaining))
+        return false;
+
+    if (size > RG_SIZE_MAX) [[unlikely]] {
+        if (flags & (int)ParseFlag::Log) {
+            LogError("Size value is too high");
+        }
+        return false;
+    }
+
+    *out_size = (Size)size;
+    return true;
+}
+#endif
+
+bool ParseDuration(Span<const char> str, int64_t *out_duration, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
+                   Span<const char> *out_remaining = nullptr);
+
 static inline Size EncodeUtf8(int32_t c, char out_buf[4])
 {
     if (c < 0x80) {
@@ -4096,11 +4118,11 @@ bool NotifySystemd();
         })()
 #endif
 
+void InitRG();
+int Main(int argc, char **argv);
+
 static inline int RunApp(int argc, char **argv)
 {
-    void InitRG();
-    int Main(int argc, char **argv);
-
     InitRG();
     return Main(argc, argv);
 }
@@ -4658,6 +4680,9 @@ public:
 
 bool SpliceStream(StreamReader *reader, int64_t max_len, StreamWriter *writer);
 
+bool IsCompressorAvailable(CompressionType compression_type);
+bool IsDecompressorAvailable(CompressionType compression_type);
+
 // For convenience, don't close them
 extern StreamReader stdin_st;
 extern StreamWriter stdout_st;

package/src/koffi/CMakeLists.txt

@@ -28,7 +28,7 @@ include(CheckCXXCompilerFlag)
 
 find_package(CNoke)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 if(MSVC)
     set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)
 

package/src/koffi/src/call.cc

@@ -1043,12 +1043,6 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                 out_kind = OutArgument::Kind::Buffer;
             } else if (type->ref.type->primitive == PrimitiveKind::Record ||
                        type->ref.type->primitive == PrimitiveKind::Union) [[likely]] {
-                if (!type->ref.type->size) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Cannot pass %1 value to %2, use koffi.as()",
-                                                type->ref.type != instance->void_type ? "opaque" : "ambiguous", type->name);
-                    return false;
-                }
-
                 Napi::Object obj = value.As<Napi::Object>();
                 RG_ASSERT(IsObject(value));
 
@@ -1108,6 +1102,22 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
             }
         } break;
 
+        case napi_function: {
+            if (type->primitive != PrimitiveKind::Callback) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Cannot pass function to type %1", type->name);
+                return false;
+            }
+
+            Napi::Function func = value.As<Napi::Function>();
+
+            void *ptr = ReserveTrampoline(type->ref.proto, func);
+            if (!ptr) [[unlikely]]
+                return false;
+
+            *out_ptr = (void *)ptr;
+            return true;
+        } break;
+
         case napi_number: {
             Napi::Number number = value.As<Napi::Number>();
             intptr_t ptr = (intptr_t)number.Int32Value();

package/src/koffi/src/ffi.cc

@@ -1775,8 +1775,9 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
     if (!type) [[unlikely]]
         return env.Null();
     if (type->primitive != PrimitiveKind::Pointer &&
+            type->primitive != PrimitiveKind::Callback &&
             type->primitive != PrimitiveKind::String &&
-            type->primitive != PrimitiveKind::String16) {
+            type->primitive != PrimitiveKind::String16) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Only pointer or string types can be used for casting");
         return env.Null();
     }