koffi 2.6.10 → 2.6.11

package/CHANGELOG.md

@@ -4,6 +4,11 @@
 
 ### Koffi 2.6
 
+#### Koffi 2.6.11 (2023-12-05)
+
+- Speed up resolving simple and often used type names
+- Fix use of optional length argument with [koffi.encode()](variables.md#encode-to-c-memory)
+
 #### Koffi 2.6.10 (2023-11-29)
 
 - Protect GetLastError() value from Node.js and V8 on Windows

package/doc/variables.md

@@ -54,7 +54,7 @@ There is also an optional ending `length` argument that you can use in two cases
 - Use it to give the number of bytes to decode in non-NUL terminated strings: `koffi.decode(value, 'char *', 5)`
 - Decode consecutive values into an array. For example, here is how you can decode an array with 3 float values: `koffi.decode(value, 'float', 3)`. This is equivalent to `koffi.decode(value, koffi.array('float', 3))`.
 
-Thge example below will decode the symbol `my_string` defined above but only the first three bytes.
+The example below will decode the symbol `my_string` defined above but only the first three bytes.
 
 ```js
 // Only decode 3 bytes from the C string my_string
@@ -69,7 +69,7 @@ In Koffi 2.2 and earlier versions, the length argument is only used to decode st
 
 *New in Koffi 2.6*
 
-Use `koffi.encode()` to encode C pointers, wrapped as external objects or as simple numbers.
+Use `koffi.encode()` to encode JS values into C symbols or pointers, wrapped as external objects or as simple numbers.
 
 Some arguments are optional and this function can be called in several ways:
 
@@ -98,3 +98,9 @@ console.log(koffi.decode(my_string, 'const char *')) // Prints "Hello World!"
 ```
 
 When encoding strings (either directly or embedded in arrays or structs), the memory will be bound to the raw pointer value and managed by Koffi. You can assign to the same string again and again without any leak or risk of use-after-free.
+
+There is also an optional ending `length` argument that you can use to encode an array. For example, here is how you can encode an array with 3 float values: `koffi.encode(symbol, 'float', [1, 2, 3], 3)`. This is equivalent to `koffi.encode(symbol, koffi.array('float', 3), [1, 2, 3])`.
+
+```{note}
+The length argument did not work correctly before Koffi 2.6.11.
+```

package/index.js

@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.6.10",
-      stable: "2.6.10",
+      version: "2.6.11",
+      stable: "2.6.11",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",

package/indirect.js

@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.6.10",
-      stable: "2.6.10",
+      version: "2.6.11",
+      stable: "2.6.11",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",

package/package.json

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

package/src/core/libcc/libcc.cc

@@ -931,6 +931,35 @@ static Span<char> FormatUnsignedToDecimal(uint64_t value, char out_buf[32])
     return MakeSpan(out_buf + offset, 32 - offset);
 }
 
+static Span<char> FormatUnsignedToBinary(uint64_t value, char out_buf[64])
+{
+    Size msb = 64 - (Size)CountLeadingZeros(value);
+    if (!msb) {
+        msb = 1;
+    }
+
+    for (Size i = 0; i < msb; i++) {
+        bool bit = (value >> (msb - i - 1)) & 0x1;
+        out_buf[i] = bit ? '1' : '0';
+    }
+
+    return MakeSpan(out_buf, msb);
+}
+
+static Span<char> FormatUnsignedToOctal(uint64_t value, char out_buf[64])
+{
+    static const char literals[] = "012345678";
+
+    Size offset = 64;
+    do {
+        uint64_t digit = value & 0x7;
+        value >>= 3;
+        out_buf[--offset] = literals[digit];
+    } while (value);
+
+    return MakeSpan(out_buf + offset, 64 - offset);
+}
+
 static Span<char> FormatUnsignedToBigHex(uint64_t value, char out_buf[32])
 {
     static const char literals[] = "0123456789ABCDEF";
@@ -959,21 +988,6 @@ static Span<char> FormatUnsignedToSmallHex(uint64_t value, char out_buf[32])
     return MakeSpan(out_buf + offset, 32 - offset);
 }
 
-static Span<char> FormatUnsignedToBinary(uint64_t value, char out_buf[64])
-{
-    Size msb = 64 - (Size)CountLeadingZeros(value);
-    if (!msb) {
-        msb = 1;
-    }
-
-    for (Size i = 0; i < msb; i++) {
-        bool bit = (value >> (msb - i - 1)) & 0x1;
-        out_buf[i] = bit ? '1' : '0';
-    }
-
-    return MakeSpan(out_buf, msb);
-}
-
 #ifdef JKJ_HEADER_DRAGONBOX
 static Size FakeFloatPrecision(Span<char> buf, int K, int min_prec, int max_prec, int *out_K)
 {
@@ -1250,6 +1264,9 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
             case FmtType::Binary: {
                 out = FormatUnsignedToBinary(arg.u.u, num_buf);
             } break;
+            case FmtType::Octal: {
+                out = FormatUnsignedToOctal(arg.u.u, num_buf);
+            } break;
             case FmtType::BigHex: {
                 out = FormatUnsignedToBigHex(arg.u.u, num_buf);
             } break;
@@ -1480,6 +1497,7 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
                         case FmtType::Integer:
                         case FmtType::Unsigned:
                         case FmtType::Binary:
+                        case FmtType::Octal:
                         case FmtType::BigHex:
                         case FmtType::SmallHex: {
                             switch (arg.u.span.type_len) {
@@ -2155,7 +2173,7 @@ fail:
     return str_buf;
 }
 
-static FileType FileAttributesToType(uint32_t attr)
+static inline FileType FileAttributesToType(uint32_t attr)
 {
     if (attr & FILE_ATTRIBUTE_DIRECTORY) {
         return FileType::Directory;

package/src/core/libcc/libcc.hh

@@ -2862,6 +2862,7 @@ enum class FmtType {
     Float,
     Double,
     Binary,
+    Octal,
     BigHex,
     SmallHex,
     MemorySize,
@@ -2960,6 +2961,13 @@ static inline FmtArg FmtBin(uint64_t u)
     arg.u.u = u;
     return arg;
 }
+static inline FmtArg FmtOctal(uint64_t u)
+{
+    FmtArg arg;
+    arg.type = FmtType::Octal;
+    arg.u.u = u;
+    return arg;
+}
 static inline FmtArg FmtHex(uint64_t u, FmtType type = FmtType::BigHex)
 {
     RG_ASSERT(type == FmtType::BigHex || type == FmtType::SmallHex);

package/src/koffi/src/ffi.cc

@@ -1966,7 +1966,7 @@ static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
 
     bool has_offset = (info.Length() >= 2 && info[1].IsNumber());
-    bool has_len = (info.Length() >= 4u + has_offset && info[2u + has_offset].IsNumber());
+    bool has_len = (info.Length() >= 4u + has_offset && info[3u + has_offset].IsNumber());
 
     if (info.Length() < 3u + has_offset) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected %1 to 5 arguments, got %2", 3 + has_offset, info.Length());
@@ -1979,10 +1979,10 @@ static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
 
     Napi::Value ref = info[0];
     int64_t offset = has_offset ? info[1].As<Napi::Number>().Int64Value() : 0;
-    Napi::Value value = info[2u + has_offset + has_len];
+    Napi::Value value = info[2u + has_offset];
 
     if (has_len) {
-        Size len = info[2u + has_offset].As<Napi::Number>();
+        Size len = info[3u + has_offset].As<Napi::Number>();
 
         if (!Encode(ref, offset, value, type, &len))
             return env.Null();

package/src/koffi/src/util.cc

@@ -117,13 +117,28 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
 
     if (value.IsString()) {
         std::string str = value.As<Napi::String>();
-        const TypeInfo *type = ResolveType(env, str.c_str(), out_directions);
 
-        if (!type) {
-            if (!env.IsExceptionPending()) {
-                ThrowError<Napi::TypeError>(env, "Unknown or invalid type name '%1'", str.c_str());
+        // Quick path for known types (int, float *, etc.)
+        const TypeInfo *type = instance->types_map.FindValue(str.c_str(), nullptr);
+
+        if (!type || (type->flags & (int)TypeFlag::IsIncomplete)) {
+            type = ResolveType(env, str.c_str(), out_directions);
+
+            if (!type) {
+                if (!env.IsExceptionPending()) {
+                    ThrowError<Napi::TypeError>(env, "Unknown or invalid type name '%1'", str.c_str());
+                }
+                return nullptr;
+            }
+
+            // Cache for quick future access
+            bool inserted;
+            auto bucket = instance->types_map.TrySetDefault(str.c_str(), &inserted);
+
+            if (inserted) {
+                bucket->key = DuplicateString(str.c_str(), &instance->str_alloc).ptr;
+                bucket->value = type;
             }
-            return nullptr;
         }
 
         return type;
@@ -200,48 +215,54 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
         }
     }
 
-    // Skip initial const qualifiers
-    str = TrimStr(str);
-    while (SplitIdentifier(str) == "const") {
-        str = str.Take(6, str.len - 6);
-        str = TrimStr(str);
-    }
-    str = TrimStr(str);
-
-    Span<const char> remain = str;
+    Span<const char> name;
+    Span<const char> after;
+    {
+        Span<const char> remain = str;
 
-    // Consume one or more identifiers (e.g. unsigned int)
-    for (;;) {
+        // Skip initial const qualifiers
+        remain = TrimStr(remain);
+        while (SplitIdentifier(remain) == "const") {
+            remain = remain.Take(6, remain.len - 6);
+            remain = TrimStr(remain);
+        }
         remain = TrimStr(remain);
 
-        Span<const char> token = SplitIdentifier(remain);
-        if (!token.len)
-            break;
-        remain = remain.Take(token.len, remain.len - token.len);
-    }
+        after = remain;
 
-    Span<const char> name = TrimStr(MakeSpan(str.ptr, remain.ptr - str.ptr));
+        // Consume one or more identifiers (e.g. unsigned int)
+        for (;;) {
+            after = TrimStr(after);
+
+            Span<const char> token = SplitIdentifier(after);
+            if (!token.len)
+                break;
+            after = after.Take(token.len, after.len - token.len);
+        }
+
+        name = TrimStr(MakeSpan(remain.ptr, after.ptr - remain.ptr));
+    }
 
     // Consume pointer indirections
-    while (remain.len) {
-        if (remain[0] == '*') {
-            remain = remain.Take(1, remain.len - 1);
+    while (after.len) {
+        if (after[0] == '*') {
+            after = after.Take(1, after.len - 1);
             indirect++;
 
             if (indirect >= RG_SIZE(disposables) * 8) [[unlikely]] {
                 ThrowError<Napi::Error>(env, "Too many pointer indirections");
                 return nullptr;
             }
-        } else if (remain[0] == '!') {
-            remain = remain.Take(1, remain.len - 1);
+        } else if (after[0] == '!') {
+            after = after.Take(1, after.len - 1);
             disposables |= (1u << indirect);
-        } else if (SplitIdentifier(remain) == "const") {
-            remain = remain.Take(6, remain.len - 6);
+        } else if (SplitIdentifier(after) == "const") {
+            after = after.Take(6, after.len - 6);
         } else {
             break;
         }
 
-        remain = TrimStr(remain);
+        after = TrimStr(after);
     }
 
     const TypeInfo *type = instance->types_map.FindValue(name, nullptr);