koffi 2.3.9 → 2.3.10-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "2.3.9",
+    "version": "2.3.10-beta.2",
     "stable": "2.3.9",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
@@ -18,15 +18,15 @@
     },
     "homepage": "https://koffi.dev/",
     "author": "Niels Martignène <niels.martignene@protonmail.com>",
-    "main": "src/koffi/src/index.js",
-    "types": "src/koffi/src/index.d.ts",
+    "main": "src/index.js",
+    "types": "src/index.d.ts",
     "scripts": {
         "install": "node src/cnoke/cnoke.js --prebuild -d src/koffi"
     },
     "license": "MIT",
     "cnoke": {
         "napi": 8,
-        "require": "./src/koffi/src/index.js",
-        "output": "src/koffi/build/{{version}}/koffi_{{platform}}_{{arch}}"
+        "require": "./src/index.js",
+        "output": "build/{{version}}/koffi_{{platform}}_{{arch}}"
     }
 }

package/src/core/libcc/libcc.cc

@@ -7415,51 +7415,103 @@ void InitPackedMap(Span<const AssetInfo> assets)
 
 #endif
 
-// This won't win any beauty or speed contest (especially when writing
-// a compressed stream) but whatever.
-Span<const uint8_t> PatchAsset(const AssetInfo &asset, Allocator *alloc,
-                               FunctionRef<void(const char *, StreamWriter *)> func)
+bool PatchFile(StreamReader *reader, StreamWriter *writer,
+               FunctionRef<void(Span<const char>, StreamWriter *)> func)
 {
-    RG_ASSERT(alloc);
-
-    HeapArray<uint8_t> buf(alloc);
-
-    StreamReader reader(asset.data, nullptr, asset.compression_type);
-    StreamWriter writer(&buf, nullptr, asset.compression_type);
-
     char c;
-    while (reader.Read(1, &c) == 1) {
+    while (reader->Read(1, &c) == 1) {
         if (c == '{') {
             char name[33] = {};
-            Size name_len = reader.Read(1, &name[0]);
+            Size name_len = reader->Read(1, &name[0]);
             RG_ASSERT(name_len >= 0);
 
             if (IsAsciiAlpha(name[0]) || name[0] == '_') {
                 do {
-                    Size read_len = reader.Read(1, &name[name_len]);
+                    Size read_len = reader->Read(1, &name[name_len]);
                     RG_ASSERT(read_len >= 0);
 
                     if (name[name_len] == '}') {
                         name[name_len] = 0;
-                        func(name, &writer);
+
+                        Span<const char> key = MakeSpan(name, name_len);
+                        func(key, writer);
 
                         break;
                     } else if (!IsAsciiAlphaOrDigit(name[name_len]) && name[name_len] != '_') {
-                        writer.Write('{');
-                        writer.Write(name, name_len + 1);
+                        writer->Write('{');
+                        writer->Write(name, name_len + 1);
 
                         break;
                     }
                 } while (++name_len < RG_SIZE(name));
             } else {
-                writer.Write('{');
-                writer.Write(name[0]);
+                writer->Write('{');
+                writer->Write(name[0]);
             }
         } else {
-            writer.Write(c);
+            writer->Write(c);
         }
     }
-    RG_ASSERT(reader.IsValid());
+
+    if (!reader->IsValid())
+        return false;
+    if (!writer->IsValid())
+        return false;
+
+    return true;
+}
+
+bool PatchFile(Span<const uint8_t> data, StreamWriter *writer,
+               FunctionRef<void(Span<const char>, StreamWriter *)> func)
+{
+    StreamReader reader(data, nullptr);
+
+    if (!PatchFile(&reader, writer, func)) {
+        RG_ASSERT(reader.IsValid());
+        return false;
+    }
+
+    return true;
+}
+
+bool PatchFile(const AssetInfo &asset, StreamWriter *writer,
+               FunctionRef<void(Span<const char>, StreamWriter *)> func)
+{
+    StreamReader reader(asset.data, nullptr, asset.compression_type);
+
+    if (!PatchFile(&reader, writer, func)) {
+        RG_ASSERT(reader.IsValid());
+        return false;
+    }
+
+    return true;
+}
+
+Span<const uint8_t> PatchFile(Span<const uint8_t> data, Allocator *alloc,
+                              FunctionRef<void(Span<const char>, StreamWriter *)> func)
+{
+    RG_ASSERT(alloc);
+
+    HeapArray<uint8_t> buf(alloc);
+    StreamWriter writer(&buf, nullptr);
+
+    PatchFile(data, &writer, func);
+
+    bool success = writer.Close();
+    RG_ASSERT(success);
+
+    return buf.Leak();
+}
+
+Span<const uint8_t> PatchFile(const AssetInfo &asset, Allocator *alloc,
+                              FunctionRef<void(Span<const char>, StreamWriter *)> func)
+{
+    RG_ASSERT(alloc);
+
+    HeapArray<uint8_t> buf(alloc);
+    StreamWriter writer(&buf, nullptr, asset.compression_type);
+
+    PatchFile(asset, &writer, func);
 
     bool success = writer.Close();
     RG_ASSERT(success);

package/src/core/libcc/libcc.hh

@@ -4610,8 +4610,17 @@ static inline const AssetInfo *FindPackedAsset(const char *name)
 
 #endif
 
-Span<const uint8_t> PatchAsset(const AssetInfo &asset, Allocator *alloc,
-                               FunctionRef<void(const char *, StreamWriter *)> func);
+// These functions won't win any beauty or speed contest but whatever
+bool PatchFile(StreamReader *reader, StreamWriter *writer,
+               FunctionRef<void(Span<const char>, StreamWriter *)> func);
+bool PatchFile(Span<const uint8_t> data, StreamWriter *writer,
+               FunctionRef<void(Span<const char>, StreamWriter *)> func);
+bool PatchFile(const AssetInfo &asset, StreamWriter *writer,
+               FunctionRef<void(Span<const char>, StreamWriter *)> func);
+Span<const uint8_t> PatchFile(Span<const uint8_t> data, Allocator *alloc,
+                              FunctionRef<void(Span<const char> key, StreamWriter *)> func);
+Span<const uint8_t> PatchFile(const AssetInfo &asset, Allocator *alloc,
+                              FunctionRef<void(Span<const char> key, StreamWriter *)> func);
 
 // ------------------------------------------------------------------------
 // Options

package/src/{koffi/src/index.js → index.js}

@@ -21,17 +21,10 @@
 
 'use strict';
 
-const cnoke = require('../../cnoke/src/index.js');
+const cnoke = require('./cnoke/src/index.js');
 const util = require('util');
 const fs = require('fs');
-
-const pkg = (() => {
-    try {
-        return require('../../../package.json');
-    } catch (err) {
-        return require('../package.json');
-    }
-})();
+const pkg = require('../package.json');
 
 if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
     let major = parseInt(process.versions.node, 10);
@@ -45,16 +38,19 @@ if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
 }
 
 let arch = cnoke.determine_arch();
-let filename = __dirname + `/../build/${pkg.version}/koffi_${process.platform}_${arch}/koffi.node`;
+let filenames = [__dirname + `/../build/${pkg.version}/koffi_${process.platform}_${arch}/koffi.node`];
 
-// Development build
-if (!fs.existsSync(filename)) {
-    let dev_filename = __dirname + '/../build/koffi.node';
-
-    if (fs.existsSync(dev_filename))
-        filename = dev_filename;
+if (process.resourcesPath != null) {
+    filenames.push(
+        process.resourcesPath + `/koffi/${pkg.version}/koffi_${process.platform}_${arch}/koffi.node`,
+        process.resourcesPath + `/build/${pkg.version}/koffi_${process.platform}_${arch}/koffi.node`
+    );
 }
 
+let filename = filenames.find(filename => fs.existsSync(filename));
+if (filename == null)
+    throw new Error('Cannot find the native Koffi module; did you bundle it correctly?');
+
 let native = require(filename);
 
 module.exports = {