koffi 2.6.10 → 2.6.12

package/CHANGELOG.md

@@ -4,6 +4,15 @@
 
 ### Koffi 2.6
 
+#### Koffi 2.6.12 (2023-12-11)
+
+- Fix possible crash introduced in Koffi 2.6.11
+
+#### 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.12",
+      stable: "2.6.12",
       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.12",
+      stable: "2.6.12",
       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.12",
+    "stable": "2.6.12",
     "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;
@@ -8354,4 +8372,72 @@ bool PromptYN(const char *prompt, bool *out_value)
     return prompter.ReadYN(out_value);
 }
 
+// ------------------------------------------------------------------------
+// Mime types
+// ------------------------------------------------------------------------
+
+const char *GetMimeType(Span<const char> extension, const char *default_type)
+{
+    static const HashMap<Span<const char>, const char *> mime_types = {
+        #define MIMETYPE(Extension, MimeType) { (Extension), (MimeType) },
+        #include "mimetypes.inc"
+
+        {"", "application/octet-stream"}
+    };
+
+    const char *mime_type = mime_types.FindValue(extension, nullptr);
+
+    if (!mime_type) {
+        LogError("Unknown MIME type for extension '%1'", extension);
+        mime_type = default_type;
+    }
+
+    return mime_type;
+}
+
+bool CanCompressFile(const char *filename)
+{
+    char extension[8];
+    {
+        const char *ptr = GetPathExtension(filename).ptr;
+
+        Size i = 0;
+        while (i < RG_SIZE(extension) - 1 && ptr[i]) {
+            extension[i] = LowerAscii(ptr[i]);
+            i++;
+        }
+        extension[i] = 0;
+    }
+
+    if (TestStrI(extension, ".zip"))
+        return false;
+    if (TestStrI(extension, ".rar"))
+        return false;
+    if (TestStrI(extension, ".7z"))
+        return false;
+    if (TestStrI(extension, ".gz") || TestStrI(extension, ".tgz"))
+        return false;
+    if (TestStrI(extension, ".bz2") || TestStrI(extension, ".tbz2"))
+        return false;
+    if (TestStrI(extension, ".xz") || TestStrI(extension, ".txz"))
+        return false;
+    if (TestStrI(extension, ".zst") || TestStrI(extension, ".tzst"))
+        return false;
+    if (TestStrI(extension, ".woff") || TestStrI(extension, ".woff2"))
+        return false;
+    if (TestStrI(extension, ".db") || TestStrI(extension, ".sqlite3"))
+        return false;
+
+    const char *mime_type = GetMimeType(extension);
+
+    if (StartsWith(mime_type, "video/"))
+        return false;
+    if (StartsWith(mime_type, "audio/"))
+        return false;
+    if (StartsWith(mime_type, "image/") && !TestStr(mime_type, "image/svg+xml"))
+        return false;
+
+    return true;
+}
+
 }

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);
@@ -5008,4 +5016,12 @@ static inline const char *Prompt(const char *prompt, Allocator *alloc)
     { return Prompt(prompt, nullptr, nullptr, alloc); }
 bool PromptYN(const char *prompt, bool *out_value);
 
+// ------------------------------------------------------------------------
+// Mime types
+// ------------------------------------------------------------------------
+
+const char *GetMimeType(Span<const char> extension, const char *default_typ = "application/octet-stream");
+
+bool CanCompressFile(const char *filename);
+
 }