koffi 2.7.1 → 2.7.2

package/CHANGELOG.md

@@ -4,6 +4,12 @@
 
 ### Koffi 2.7
 
+#### Koffi 2.7.2 (2024-01-15)
+
+- Add missing TypeScript declaration for `koffi.free()`
+- Fix TypeScript declaration of `koffi.encode()`
+- Try to improve compatibility with webpack
+
 #### Koffi 2.7.1 (2024-01-02)
 
 - Support C-like `int[3]` syntax for [fixed array types](input.md#fixed-size-c-arrays)

package/README.md

@@ -25,9 +25,9 @@ Go to the web site for more information: https://koffi.dev/
 
 # Project history
 
-You can consult the [changelog](https://koffi.dev/changes) on the official website.
+You can consult the [changelog](https://koffi.dev/changelog) on the official website.
 
-Major version increments can include breaking API changes, use the [migration guide](https://koffi.dev/changes#migration-guide) for more information.
+Major version increments can include breaking API changes, use the [migration guide](https://koffi.dev/changelog#migration-guide) for more information.
 
 # License
 

package/doc/unions.md

@@ -49,8 +49,8 @@ const U = koffi.union('U', { i: 'int', str: 'char *' });
 
 const DoSomething = lib.func('void DoSomething(const char *type, U u)');
 
-DoSomething('int', { .i = 42 });
-DoSomething('string', { .str = 'Hello!' });
+DoSomething('int', { i: 42 });
+DoSomething('string', { str: 'Hello!' });
 ```
 
 ### Win32 example

package/index.d.ts

@@ -132,7 +132,6 @@ declare module 'koffi' {
     export function decode(value: any, offset: number, type: TypeSpec, len: number): any;
     export function address(value: any): bigint;
     export function call(value: any, type: TypeSpec, ...args: any[]): any;
-    export function encode(ref: any, type: TypeSpec): void;
     export function encode(ref: any, type: TypeSpec, value: any): void;
     export function encode(ref: any, type: TypeSpec, value: any, len: number): void;
     export function encode(ref: any, offset: number, type: TypeSpec): void;
@@ -151,6 +150,8 @@ declare module 'koffi' {
     export function config(cfg: Record<string, unknown>): Record<string, unknown>;
     export function stats(): Record<string, unknown>;
 
+    export function free(value: any): void;
+
     export function errno(): number;
     export function errno(value: number): number;
 

package/index.js

@@ -69,17 +69,17 @@ var require_tools = __commonJS({
         try {
           crypto.randomFillSync(buf);
           let suffix = buf.toString("hex").padStart(8, "0");
-          let filename = `${prefix}.${suffix}`;
-          let file = fs2.createWriteStream(filename, { flags: "wx", mode: 420 });
-          return [filename, file];
+          let filename2 = `${prefix}.${suffix}`;
+          let file = fs2.createWriteStream(filename2, { flags: "wx", mode: 420 });
+          return [filename2, file];
         } catch (err) {
           if (err.code != "EEXIST")
             throw err;
         }
       }
     }
-    function extract_targz(filename, dest_dir, strip = 0) {
-      let reader = fs2.createReadStream(filename).pipe(zlib.createGunzip());
+    function extract_targz(filename2, dest_dir, strip = 0) {
+      let reader = fs2.createReadStream(filename2).pipe(zlib.createGunzip());
       return new Promise((resolve, reject) => {
         let header = null;
         let extended = {};
@@ -119,13 +119,13 @@ var require_tools = __commonJS({
               }
               data = data.subarray(0, header.size);
               if (header.type == "0" || header.type == "7") {
-                let filename2 = dest_dir + "/" + header.filename;
-                let dirname = path.dirname(filename2);
+                let filename3 = dest_dir + "/" + header.filename;
+                let dirname = path.dirname(filename3);
                 fs2.mkdirSync(dirname, { recursive: true, mode: 493 });
-                fs2.writeFileSync(filename2, data, { mode: header.mode });
+                fs2.writeFileSync(filename3, data, { mode: header.mode });
               } else if (header.type == "5") {
-                let filename2 = dest_dir + "/" + header.filename;
-                fs2.mkdirSync(filename2, { recursive: true, mode: header.mode });
+                let filename3 = dest_dir + "/" + header.filename;
+                fs2.mkdirSync(filename3, { recursive: true, mode: header.mode });
               } else if (header.type == "L") {
                 extended.filename = data.toString("utf-8").replace(/\0/g, "");
               } else if (header.type == "x") {
@@ -233,10 +233,10 @@ var require_tools = __commonJS({
       }
       return arch2;
     }
-    function read_file_header(filename, read) {
+    function read_file_header(filename2, read) {
       let fd = null;
       try {
-        let fd2 = fs2.openSync(filename);
+        let fd2 = fs2.openSync(filename2);
         let buf = Buffer.allocUnsafe(read);
         let len = fs2.readSync(fd2, buf);
         return buf.subarray(0, len);
@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.7.1",
-      stable: "2.7.1",
+      version: "2.7.2",
+      stable: "2.7.2",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -527,24 +527,24 @@ try {
 } catch (err) {
 }
 if (native == null) {
+  let roots = [__dirname];
+  if (process.resourcesPath != null)
+    roots.push(process.resourcesPath);
   let names = [
     `/build/koffi/${process.platform}_${arch}/koffi.node`,
     `/koffi/${process.platform}_${arch}/koffi.node`,
     `/node_modules/koffi/build/koffi/${process.platform}_${arch}/koffi.node`
   ];
-  for (let name of names) {
-    if (fs.existsSync(__dirname + name)) {
-      native = require(__dirname + name);
-      break;
-    }
-  }
-  if (native == null && process.resourcesPath != null) {
+  for (let root of roots) {
     for (let name of names) {
-      if (fs.existsSync(process.resourcesPath + name)) {
-        native = require(process.resourcesPath + name);
+      let filename = root + name;
+      if (fs.existsSync(filename)) {
+        native = eval("require")(filename);
         break;
       }
     }
+    if (native != null)
+      break;
   }
 }
 if (native == null)

package/indirect.js

@@ -69,17 +69,17 @@ var require_tools = __commonJS({
         try {
           crypto.randomFillSync(buf);
           let suffix = buf.toString("hex").padStart(8, "0");
-          let filename = `${prefix}.${suffix}`;
-          let file = fs2.createWriteStream(filename, { flags: "wx", mode: 420 });
-          return [filename, file];
+          let filename2 = `${prefix}.${suffix}`;
+          let file = fs2.createWriteStream(filename2, { flags: "wx", mode: 420 });
+          return [filename2, file];
         } catch (err) {
           if (err.code != "EEXIST")
             throw err;
         }
       }
     }
-    function extract_targz(filename, dest_dir, strip = 0) {
-      let reader = fs2.createReadStream(filename).pipe(zlib.createGunzip());
+    function extract_targz(filename2, dest_dir, strip = 0) {
+      let reader = fs2.createReadStream(filename2).pipe(zlib.createGunzip());
       return new Promise((resolve, reject) => {
         let header = null;
         let extended = {};
@@ -119,13 +119,13 @@ var require_tools = __commonJS({
               }
               data = data.subarray(0, header.size);
               if (header.type == "0" || header.type == "7") {
-                let filename2 = dest_dir + "/" + header.filename;
-                let dirname = path.dirname(filename2);
+                let filename3 = dest_dir + "/" + header.filename;
+                let dirname = path.dirname(filename3);
                 fs2.mkdirSync(dirname, { recursive: true, mode: 493 });
-                fs2.writeFileSync(filename2, data, { mode: header.mode });
+                fs2.writeFileSync(filename3, data, { mode: header.mode });
               } else if (header.type == "5") {
-                let filename2 = dest_dir + "/" + header.filename;
-                fs2.mkdirSync(filename2, { recursive: true, mode: header.mode });
+                let filename3 = dest_dir + "/" + header.filename;
+                fs2.mkdirSync(filename3, { recursive: true, mode: header.mode });
               } else if (header.type == "L") {
                 extended.filename = data.toString("utf-8").replace(/\0/g, "");
               } else if (header.type == "x") {
@@ -233,10 +233,10 @@ var require_tools = __commonJS({
       }
       return arch2;
     }
-    function read_file_header(filename, read) {
+    function read_file_header(filename2, read) {
       let fd = null;
       try {
-        let fd2 = fs2.openSync(filename);
+        let fd2 = fs2.openSync(filename2);
         let buf = Buffer.allocUnsafe(read);
         let len = fs2.readSync(fd2, buf);
         return buf.subarray(0, len);
@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.7.1",
-      stable: "2.7.1",
+      version: "2.7.2",
+      stable: "2.7.2",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -447,24 +447,24 @@ var arch = determine_arch();
 var triplet = `${process.platform}_${arch}`;
 var native = null;
 {
+  let roots = [__dirname];
+  if (process.resourcesPath != null)
+    roots.push(process.resourcesPath);
   let names = [
     `/build/koffi/${process.platform}_${arch}/koffi.node`,
     `/koffi/${process.platform}_${arch}/koffi.node`,
     `/node_modules/koffi/build/koffi/${process.platform}_${arch}/koffi.node`
   ];
-  for (let name of names) {
-    if (fs.existsSync(__dirname + name)) {
-      native = require(__dirname + name);
-      break;
-    }
-  }
-  if (native == null && process.resourcesPath != null) {
+  for (let root of roots) {
     for (let name of names) {
-      if (fs.existsSync(process.resourcesPath + name)) {
-        native = require(process.resourcesPath + name);
+      let filename = root + name;
+      if (fs.existsSync(filename)) {
+        native = eval("require")(filename);
         break;
       }
     }
+    if (native != null)
+      break;
   }
 }
 if (native == null)

package/package.json

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

package/src/core/libcc/brotli.cc

@@ -26,7 +26,7 @@
 
 namespace RG {
 
-class BrotliDecompressor: public StreamDecompressor {
+class BrotliDecompressor: public StreamDecoder {
     BrotliDecoderState *state = nullptr;
     bool done = false;
 
@@ -37,27 +37,23 @@ class BrotliDecompressor: public StreamDecompressor {
     Size out_len = 0;
 
 public:
-    BrotliDecompressor(StreamReader *reader) : StreamDecompressor(reader) {}
+    BrotliDecompressor(StreamReader *reader, CompressionType type);
     ~BrotliDecompressor();
 
-    bool Init(CompressionType type) override;
     Size Read(Size max_len, void *out_buf) override;
 };
 
-BrotliDecompressor::~BrotliDecompressor()
-{
-    if (state) {
-        BrotliDecoderDestroyInstance(state);
-    }
-}
-
-bool BrotliDecompressor::Init(CompressionType)
+BrotliDecompressor::BrotliDecompressor(StreamReader *reader, CompressionType)
+    : StreamDecoder(reader)
 {
     state = BrotliDecoderCreateInstance(nullptr, nullptr, nullptr);
     if (!state)
         throw std::bad_alloc();
+}
 
-    return true;
+BrotliDecompressor::~BrotliDecompressor()
+{
+    BrotliDecoderDestroyInstance(state);
 }
 
 Size BrotliDecompressor::Read(Size max_len, void *user_buf)
@@ -105,26 +101,19 @@ Size BrotliDecompressor::Read(Size max_len, void *user_buf)
     RG_UNREACHABLE();
 }
 
-class BrotliCompressor: public StreamCompressor {
+class BrotliCompressor: public StreamEncoder {
     BrotliEncoderStateStruct *state = nullptr;
 
 public:
-    BrotliCompressor(StreamWriter *writer) : StreamCompressor(writer) {}
+    BrotliCompressor(StreamWriter *writer, CompressionType type, CompressionSpeed speed);
     ~BrotliCompressor();
 
-    bool Init(CompressionType type, CompressionSpeed speed) override;
     bool Write(Span<const uint8_t> buf) override;
     bool Finalize() override;
 };
 
-BrotliCompressor::~BrotliCompressor()
-{
-    if (state) {
-        BrotliEncoderDestroyInstance(state);
-    }
-}
-
-bool BrotliCompressor::Init(CompressionType, CompressionSpeed speed)
+BrotliCompressor::BrotliCompressor(StreamWriter *writer, CompressionType, CompressionSpeed speed)
+    : StreamEncoder(writer)
 {
     state = BrotliEncoderCreateInstance(nullptr, nullptr, nullptr);
     if (!state)
@@ -137,8 +126,11 @@ bool BrotliCompressor::Init(CompressionType, CompressionSpeed speed)
         case CompressionSpeed::Slow: { BrotliEncoderSetParameter(state, BROTLI_PARAM_QUALITY, 11); } break;
         case CompressionSpeed::Fast: { BrotliEncoderSetParameter(state, BROTLI_PARAM_QUALITY, 0); } break;
     }
+}
 
-    return true;
+BrotliCompressor::~BrotliCompressor()
+{
+    BrotliEncoderDestroyInstance(state);
 }
 
 bool BrotliCompressor::Write(Span<const uint8_t> buf)

package/src/core/libcc/libcc.cc

@@ -1932,6 +1932,23 @@ bool GetDebugFlag(const char *name)
     }
 }
 
+#ifndef NDEBUG
+const char *DebugLogContext(const char *filename, int line)
+{
+    static RG_THREAD_LOCAL LocalArray<char, 1024> buf;
+
+    buf.len = Fmt(buf.data, "  [%1:%2] ", filename, line).len;
+
+    if (buf.len > 32) {
+        char *ptr = buf.end() - 32;
+        memcpy(ptr, "  [...", 6);
+        return ptr;
+    } else {
+        return buf.data;
+    }
+}
+#endif
+
 static void RunLogFilter(Size idx, LogLevel level, const char *ctx, const char *msg)
 {
     const std::function<LogFilterFunc> &func = *log_filters[idx];
@@ -2001,9 +2018,9 @@ void DefaultLogHandler(LogLevel level, const char *ctx, const char *msg)
 {
     switch (level)  {
         case LogLevel::Debug:
-        case LogLevel::Info: { PrintLn(stderr, "%!D..%1%2%!0%3", ctx ? ctx : "", ctx ? ": " : "", msg); } break;
-        case LogLevel::Warning: { PrintLn(stderr, "%!M..%1%2%!0%3", ctx ? ctx : "", ctx ? ": " : "", msg); } break;
-        case LogLevel::Error: { PrintLn(stderr, "%!R..%1%2%!0%3", ctx ? ctx : "", ctx ? ": " : "", msg); } break;
+        case LogLevel::Info: { PrintLn(stderr, "%!D..%1%!0%2", ctx ? ctx : "", msg); } break;
+        case LogLevel::Warning: { PrintLn(stderr, "%!M..%1%!0%2", ctx ? ctx : "", msg); } break;
+        case LogLevel::Error: { PrintLn(stderr, "%!R..%1%!0%2", ctx ? ctx : "", msg); } break;
     }
 
     fflush(stderr);
@@ -2047,11 +2064,10 @@ bool RedirectLogToWindowsEvents(const char *name)
 
         // Append context
         if (ctx) {
-            Size len = ConvertUtf8ToWin32Wide(ctx, buf_w.Take(0, RG_LEN(buf_w.data) / 2));
+            Size len = ConvertUtf8ToWin32Wide(ctx, buf_w.TakeAvailable());
             if (len < 0)
                 return;
-            wcscpy(buf_w.data + len, L": ");
-            buf_w.len += len + 2;
+            buf_w.len += len;
         }
 
         // Append message
@@ -6182,6 +6198,15 @@ StreamWriter stderr_st(stderr, "<stderr>");
 static CreateDecompressorFunc *DecompressorFunctions[RG_LEN(CompressionTypeNames)];
 static CreateCompressorFunc *CompressorFunctions[RG_LEN(CompressionTypeNames)];
 
+void StreamReader::SetDecoder(StreamDecoder *decoder)
+{
+    RG_ASSERT(decoder);
+    RG_ASSERT(!filename);
+    RG_ASSERT(!this->decoder);
+
+    this->decoder = decoder;
+}
+
 bool StreamReader::Open(Span<const uint8_t> buf, const char *filename,
                         CompressionType compression_type)
 {
@@ -6286,9 +6311,9 @@ bool StreamReader::Close(bool implicit)
 {
     RG_ASSERT(implicit || this != &stdin_st);
 
-    if (decompressor) {
-        RG_ASSERT(compression_type != CompressionType::None);
-        delete decompressor;
+    if (decoder) {
+        delete decoder;
+        decoder = nullptr;
     }
 
     switch (source.type) {
@@ -6308,7 +6333,6 @@ bool StreamReader::Close(bool implicit)
 
     filename = nullptr;
     error = true;
-    compression_type = CompressionType::None;
     source.type = SourceType::Memory;
     source.eof = false;
     eof = false;
@@ -6323,6 +6347,11 @@ bool StreamReader::Rewind()
     if (error) [[unlikely]]
         return false;
 
+    if (decoder) [[unlikely]] {
+        LogError("Cannot rewind stream with decoder");
+        return false;
+    }
+
     switch (source.type) {
         case SourceType::Memory: { source.u.memory.pos = 0; } break;
         case SourceType::File: {
@@ -6339,14 +6368,6 @@ bool StreamReader::Rewind()
         } break;
     }
 
-    if (decompressor) {
-        RG_ASSERT(compression_type != CompressionType::None);
-        delete decompressor;
-
-        if (!InitDecompressor(compression_type))
-            return false;
-    }
-
     source.eof = false;
     eof = false;
 
@@ -6376,14 +6397,10 @@ Size StreamReader::Read(Span<uint8_t> out_buf)
         return -1;
 
     Size read_len = 0;
-    if (decompressor) {
-        RG_ASSERT(compression_type != CompressionType::None);
-
-        read_len = decompressor->Read(out_buf.len, out_buf.ptr);
+    if (decoder) {
+        read_len = decoder->Read(out_buf.len, out_buf.ptr);
         error |= (read_len < 0);
     } else {
-        RG_ASSERT(compression_type == CompressionType::None);
-
         read_len = ReadRaw(out_buf.len, out_buf.ptr);
         eof = source.eof;
     }
@@ -6421,7 +6438,7 @@ Size StreamReader::ReadAll(Size max_len, HeapArray<uint8_t> *out_buf)
     // For some files (such as in /proc), the file size is reported as 0 even though there
     // is content inside, because these files are generated on demand. So we need to take
     // the slow path for apparently empty files.
-    if (compression_type == CompressionType::None && ComputeRawLen() > 0) {
+    if (!decoder && ComputeRawLen() > 0) {
         if (raw_len > max_len) {
             LogError("File '%1' is too large (limit = %2)", filename, FmtDiskSize(max_len));
             return -1;
@@ -6510,19 +6527,10 @@ bool StreamReader::InitDecompressor(CompressionType type)
             return false;
         }
 
-        decompressor = func(this);
-
-        if (!decompressor) {
-            error = true;
-            return false;
-        }
-        if (!decompressor->Init(type)) {
-            error = true;
-            return false;
-        }
+        decoder = func(this, type);
+        RG_ASSERT(decoder);
     }
 
-    compression_type = type;
     return true;
 }
 
@@ -6621,23 +6629,23 @@ void LineReader::PushLogFilter()
         char ctx_buf[1024];
 
         if (line_number > 0) {
-            Fmt(ctx_buf, "%1(%2)%3%4", st->GetFileName(), line_number, ctx ? ": " : "", ctx ? ctx : "");
+            Fmt(ctx_buf, "%1%2(%3): ", ctx ? ctx : "", st->GetFileName(), line_number);
         } else {
-            Fmt(ctx_buf, "%1%2%3", st->GetFileName(), ctx ? ": " : "", ctx ? ctx : "");
+            Fmt(ctx_buf, "%1%2: ", ctx ? ctx : "", st->GetFileName());
         }
 
         func(level, ctx_buf, msg);
     });
 }
 
-#ifdef LZ4_VERSION_MAJOR
-struct LZ4CompressContext {
-    LZ4F_cctx *encoder;
-    LZ4F_preferences_t prefs = {};
+void StreamWriter::SetEncoder(StreamEncoder *encoder)
+{
+    RG_ASSERT(encoder);
+    RG_ASSERT(!filename);
+    RG_ASSERT(!this->encoder);
 
-    HeapArray<uint8_t> buf;
-};
-#endif
+    this->encoder = encoder;
+}
 
 bool StreamWriter::Open(HeapArray<uint8_t> *mem, const char *filename,
                         CompressionType compression_type, CompressionSpeed compression_speed)
@@ -6802,10 +6810,8 @@ bool StreamWriter::Write(Span<const uint8_t> buf)
     if (error) [[unlikely]]
         return false;
 
-    if (compressor) {
-        RG_ASSERT(compression_type != CompressionType::None);
-
-        error |= !compressor->Write(buf);
+    if (encoder) {
+        error |= !encoder->Write(buf);
         return !error;
     } else {
         return WriteRaw(buf);
@@ -6817,11 +6823,11 @@ bool StreamWriter::Close(bool implicit)
     RG_ASSERT(implicit || this != &stdout_st);
     RG_ASSERT(implicit || this != &stderr_st);
 
-    if (compressor && !error) {
-        RG_ASSERT(compression_type != CompressionType::None);
-        error |= !compressor->Finalize();
+    if (encoder) {
+        error = error || !encoder->Finalize();
 
-        delete compressor;
+        delete encoder;
+        encoder = nullptr;
     }
 
     switch (dest.type) {
@@ -6880,7 +6886,6 @@ bool StreamWriter::Close(bool implicit)
 
     filename = nullptr;
     error = true;
-    compression_type = CompressionType::None;
     dest.type = DestinationType::Memory;
     str_alloc.ReleaseAll();
 
@@ -6898,21 +6903,10 @@ bool StreamWriter::InitCompressor(CompressionType type, CompressionSpeed speed)
             return false;
         }
 
-        compressor = func(this);
-
-        if (!compressor) {
-            error = true;
-            return false;
-        }
-        if (!compressor->Init(type, speed)) {
-            error = true;
-            return false;
-        }
+        encoder = func(this, type, speed);
+        RG_ASSERT(encoder);
     }
 
-    compression_type = type;
-    compression_speed = speed;
-
     return true;
 }
 
@@ -7013,14 +7007,14 @@ bool IsDecompressorAvailable(CompressionType compression_type)
 static bool CheckIniKey(Span<const char> key)
 {
     const auto test_char = [](char c) { return IsAsciiAlphaOrDigit(c) || c == '_' ||
-                                               c == '-' || c == '.' || c == '/'; };
+                                               c == '-' || c == '.' || c == '/' || c == '@'; };
 
     if (!key.len) {
         LogError("INI key cannot be empty");
         return false;
     }
     if (!std::all_of(key.begin(), key.end(), test_char)) {
-        LogError("INI key must only contain alphanumeric, '.', '-' or '_' characters");
+        LogError("INI key must only contain alphanumeric, '.', '-', '_', '/' or '@' characters");
         return false;
     }
 

package/src/core/libcc/libcc.hh

@@ -249,14 +249,6 @@ extern "C" void AssertMessage(const char *filename, int line, const char *cond);
     #define RG_UNREACHABLE() __assume(0)
 #endif
 
-#if defined(__EMSCRIPTEN__)
-    #define RG_EXPORT EMSCRIPTEN_KEEPALIVE
-#elif defined(_WIN32)
-    #define RG_EXPORT __declspec(dllexport)
-#else
-    #define RG_EXPORT __attribute__((visibility("default")))
-#endif
-
 #define RG_DELETE_COPY(Cls) \
     Cls(const Cls&) = delete; \
     Cls &operator=(const Cls&) = delete;
@@ -1221,11 +1213,7 @@ public:
         RG_ASSERT(len <= N - count);
 
         T *first = data + len;
-#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
-#else
-        if (true) {
-#endif
             for (Size i = 0; i < count; i++) {
                 new (data + len) T();
                 len++;
@@ -1323,11 +1311,7 @@ public:
     {
         RemoveFrom(0);
         Grow(other.capacity);
-#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
-#else
-        if (true) {
-#endif
             for (Size i = 0; i < other.len; i++) {
                 ptr[i] = other.ptr[i];
             }
@@ -1432,11 +1416,7 @@ public:
         Grow(count);
 
         T *first = ptr + len;
-#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
-#else
-        if (true) {
-#endif
             for (Size i = 0; i < count; i++) {
                 new (ptr + len) T();
                 len++;
@@ -1454,11 +1434,7 @@ public:
         Grow();
 
         T *first = ptr + len;
-#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
-#else
-        if (true) {
-#endif
             new (ptr + len) T;
         }
         ptr[len++] = value;
@@ -1470,11 +1446,7 @@ public:
 
         T *first = ptr + len;
         for (const T &value: values) {
-#if __cplusplus >= 201703L
             if constexpr(!std::is_trivial<T>::value) {
-#else
-            if (true) {
-#endif
                 new (ptr + len) T;
             }
             ptr[len++] = value;
@@ -1486,11 +1458,7 @@ public:
     {
         RG_ASSERT(first >= 0 && first <= len);
 
-#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
-#else
-        if (true) {
-#endif
             for (Size i = first; i < len; i++) {
                 ptr[i].~T();
             }
@@ -1796,11 +1764,7 @@ private:
     void DeleteValues([[maybe_unused]] iterator_type begin,
                       [[maybe_unused]] iterator_type end)
     {
-#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
-#else
-        if (true) {
-#endif
             for (iterator_type it = begin; it != end; ++it) {
                 it->~T();
             }
@@ -2077,11 +2041,7 @@ public:
     }
     ~HashTable()
     {
-#if __cplusplus >= 201703L
         if constexpr(std::is_trivial<ValueType>::value) {
-#else
-        if (false) {
-#endif
             count = 0;
             Rehash(0);
         } else {
@@ -2278,11 +2238,7 @@ private:
     template <typename T = KeyType>
     const ValueType *Find(Size *idx, const T &key) const
     {
-#if __cplusplus >= 201703L
         if constexpr(std::is_pointer<ValueType>::value) {
-#else
-        if (false) {
-#endif
             while (data[*idx]) {
                 const KeyType &it_key = Handler::GetKey(data[*idx]);
                 if (Handler::TestKeys(it_key, key))
@@ -3184,18 +3140,22 @@ static inline void Log(LogLevel level, const char *ctx, const char *fmt, Args...
 
 // Shortcut log functions
 #ifdef RG_DEBUG
-template <typename... Args>
-static inline void LogDebug(Args... args) { Log(LogLevel::Debug, "Debug", args...); }
+    const char *DebugLogContext(const char *filename, int line);
+
+    #define LogDebug(...) Log(LogLevel::Debug, DebugLogContext(__FILE__, __LINE__) __VA_OPT__(,) __VA_ARGS__)
+    #define LogInfo(...) Log(LogLevel::Info, nullptr __VA_OPT__(,) __VA_ARGS__)
+    #define LogWarning(...) Log(LogLevel::Warning, DebugLogContext(__FILE__, __LINE__) __VA_OPT__(,) __VA_ARGS__)
+    #define LogError(...) Log(LogLevel::Error, DebugLogContext(__FILE__, __LINE__) __VA_OPT__(,) __VA_ARGS__)
 #else
-template <typename... Args>
-static inline void LogDebug(Args...) {}
+    template <typename... Args>
+    static inline void LogDebug(Args...) {}
+    template <typename... Args>
+    static inline void LogInfo(Args... args) { Log(LogLevel::Info, nullptr, args...); }
+    template <typename... Args>
+    static inline void LogWarning(Args... args) { Log(LogLevel::Warning, "Warning: ", args...); }
+    template <typename... Args>
+    static inline void LogError(Args... args) { Log(LogLevel::Error, "Error: ", args...); }
 #endif
-template <typename... Args>
-static inline void LogInfo(Args... args) { Log(LogLevel::Info, nullptr, args...); }
-template <typename... Args>
-static inline void LogWarning(Args... args) { Log(LogLevel::Warning, "Warning", args...); }
-template <typename... Args>
-static inline void LogError(Args... args) { Log(LogLevel::Error, "Error", args...); }
 
 void SetLogHandler(const std::function<LogFunc> &func);
 void DefaultLogHandler(LogLevel level, const char *ctx, const char *msg);
@@ -3301,7 +3261,7 @@ static inline bool TestStrI(Span<const char> str1, const char *str2)
     return (i == str1.len) && !str2[i];
 }
 static inline bool TestStrI(const char *str1, Span<const char> str2)
-    { return TestStr(str2, str1); }
+    { return TestStrI(str2, str1); }
 static inline bool TestStrI(const char *str1, const char *str2)
 {
     Size i = 0;
@@ -4344,8 +4304,8 @@ enum class CompressionSpeed {
     Fast
 };
 
-class StreamDecompressor;
-class StreamCompressor;
+class StreamDecoder;
+class StreamEncoder;
 
 class StreamReader {
     RG_DELETE_COPY(StreamReader)
@@ -4383,8 +4343,7 @@ class StreamReader {
         bool eof = false;
     } source;
 
-    CompressionType compression_type = CompressionType::None;
-    StreamDecompressor *decompressor = nullptr;
+    StreamDecoder *decoder = nullptr;
 
     int64_t raw_len = -1;
     Size raw_read = 0;
@@ -4408,6 +4367,9 @@ public:
         : StreamReader() { Open(func, filename, compression_type); }
     ~StreamReader() { Close(true); }
 
+    // Call before Open!
+    void SetDecoder(StreamDecoder *decoder);
+
     bool Open(Span<const uint8_t> buf, const char *filename = nullptr,
               CompressionType compression_type = CompressionType::None);
     bool Open(FILE *fp, const char *filename,
@@ -4421,7 +4383,6 @@ public:
     bool Rewind();
 
     const char *GetFileName() const { return filename; }
-    CompressionType GetCompressionType() const { return compression_type; }
     int64_t GetReadLimit() { return read_max; }
     bool IsValid() const { return filename && !error; }
     bool IsEOF() const { return eof; }
@@ -4449,62 +4410,38 @@ private:
 
     Size ReadRaw(Size max_len, void *out_buf);
 
-    friend class StreamDecompressor;
+    friend class StreamDecoder;
 };
 
-static inline Size ReadFile(const char *filename, CompressionType compression_type, Span<uint8_t> out_buf)
-{
-    StreamReader st(filename, compression_type);
-    return st.Read(out_buf);
-}
 static inline Size ReadFile(const char *filename, Span<uint8_t> out_buf)
 {
     StreamReader st(filename);
     return st.Read(out_buf);
 }
-static inline Size ReadFile(const char *filename, CompressionType compression_type, Span<char> out_buf)
-{
-    StreamReader st(filename, compression_type);
-    return st.Read(out_buf);
-}
 static inline Size ReadFile(const char *filename, Span<char> out_buf)
 {
     StreamReader st(filename);
     return st.Read(out_buf);
 }
-
-static inline Size ReadFile(const char *filename, Size max_len, CompressionType compression_type,
-                            HeapArray<uint8_t> *out_buf)
-{
-    StreamReader st(filename, compression_type);
-    return st.ReadAll(max_len, out_buf);
-}
 static inline Size ReadFile(const char *filename, Size max_len, HeapArray<uint8_t> *out_buf)
 {
     StreamReader st(filename);
     return st.ReadAll(max_len, out_buf);
 }
-static inline Size ReadFile(const char *filename, Size max_len, CompressionType compression_type,
-                            HeapArray<char> *out_buf)
-{
-    StreamReader st(filename, compression_type);
-    return st.ReadAll(max_len, out_buf);
-}
 static inline Size ReadFile(const char *filename, Size max_len, HeapArray<char> *out_buf)
 {
     StreamReader st(filename);
     return st.ReadAll(max_len, out_buf);
 }
 
-class StreamDecompressor {
+class StreamDecoder {
 protected:
     StreamReader *reader;
 
 public:
-    StreamDecompressor(StreamReader *reader) : reader(reader) {}
-    virtual ~StreamDecompressor() {}
+    StreamDecoder(StreamReader *reader) : reader(reader) {}
+    virtual ~StreamDecoder() {}
 
-    virtual bool Init(CompressionType type) = 0;
     virtual Size Read(Size max_len, void *out_buf) = 0;
 
 protected:
@@ -4517,7 +4454,7 @@ protected:
     void SetEOF(bool eof) { reader->eof = eof; }
 };
 
-typedef StreamDecompressor *CreateDecompressorFunc(StreamReader *reader);
+typedef StreamDecoder *CreateDecompressorFunc(StreamReader *reader, CompressionType type);
 
 class StreamDecompressorHelper {
 public:
@@ -4525,9 +4462,9 @@ public:
 };
 
 #define RG_REGISTER_DECOMPRESSOR(Type, Cls) \
-    static StreamDecompressor *RG_UNIQUE_NAME(CreateDecompressor)(StreamReader *reader) \
+    static StreamDecoder *RG_UNIQUE_NAME(CreateDecompressor)(StreamReader *reader, CompressionType type) \
     { \
-        StreamDecompressor *decompressor = new Cls(reader); \
+        StreamDecoder *decompressor = new Cls(reader, type); \
         return decompressor; \
     } \
     static StreamDecompressorHelper RG_UNIQUE_NAME(CreateDecompressorHelper)((Type), RG_UNIQUE_NAME(CreateDecompressor))
@@ -4601,9 +4538,7 @@ class StreamWriter {
         bool vt100;
     } dest;
 
-    CompressionType compression_type = CompressionType::None;
-    CompressionSpeed compression_speed = CompressionSpeed::Default;
-    StreamCompressor *compressor = nullptr;
+    StreamEncoder *encoder = nullptr;
 
     int64_t raw_written = 0;
 
@@ -4633,6 +4568,9 @@ public:
         : StreamWriter() { Open(func, filename, compression_type, compression_speed); }
     ~StreamWriter() { Close(true); }
 
+    // Call before Open!
+    void SetEncoder(StreamEncoder *encoder);
+
     bool Open(HeapArray<uint8_t> *mem, const char *filename = nullptr,
               CompressionType compression_type = CompressionType::None,
               CompressionSpeed compression_speed = CompressionSpeed::Default);
@@ -4655,8 +4593,6 @@ public:
     bool Flush();
 
     const char *GetFileName() const { return filename; }
-    CompressionType GetCompressionType() const { return compression_type; }
-    CompressionSpeed GetCompressionSpeed() const { return compression_speed; }
     bool IsVt100() const { return dest.vt100; }
     bool IsValid() const { return filename && !error; }
 
@@ -4677,33 +4613,30 @@ private:
 
     bool WriteRaw(Span<const uint8_t> buf);
 
-    friend class StreamCompressor;
+    friend class StreamEncoder;
 };
 
-static inline bool WriteFile(Span<const uint8_t> buf, const char *filename, unsigned int flags = 0,
-                             CompressionType compression_type = CompressionType::None)
+static inline bool WriteFile(Span<const uint8_t> buf, const char *filename, unsigned int flags = 0)
 {
-    StreamWriter st(filename, flags, compression_type);
+    StreamWriter st(filename, flags);
     st.Write(buf);
     return st.Close();
 }
-static inline bool WriteFile(Span<const char> buf, const char *filename, unsigned int flags = 0,
-                             CompressionType compression_type = CompressionType::None)
+static inline bool WriteFile(Span<const char> buf, const char *filename, unsigned int flags = 0)
 {
-    StreamWriter st(filename, flags, compression_type);
+    StreamWriter st(filename, flags);
     st.Write(buf);
     return st.Close();
 }
 
-class StreamCompressor {
+class StreamEncoder {
 protected:
     StreamWriter *writer;
 
 public:
-    StreamCompressor(StreamWriter *writer) : writer(writer) {}
-    virtual ~StreamCompressor() {}
+    StreamEncoder(StreamWriter *writer) : writer(writer) {}
+    virtual ~StreamEncoder() {}
 
-    virtual bool Init(CompressionType type, CompressionSpeed speed) = 0;
     virtual bool Write(Span<const uint8_t> buf) = 0;
     virtual bool Finalize() = 0;
 
@@ -4714,7 +4647,7 @@ protected:
     bool WriteRaw(Span<const uint8_t> buf) { return writer->WriteRaw(buf); }
 };
 
-typedef StreamCompressor *CreateCompressorFunc(StreamWriter *writer);
+typedef StreamEncoder *CreateCompressorFunc(StreamWriter *writer, CompressionType type, CompressionSpeed speed);
 
 class StreamCompressorHelper {
 public:
@@ -4722,9 +4655,9 @@ public:
 };
 
 #define RG_REGISTER_COMPRESSOR(Type, Cls) \
-    static StreamCompressor *RG_UNIQUE_NAME(CreateCompressor)(StreamWriter *writer) \
+    static StreamEncoder *RG_UNIQUE_NAME(CreateCompressor)(StreamWriter *writer, CompressionType type, CompressionSpeed speed) \
     { \
-        StreamCompressor *compressor = new Cls(writer); \
+        StreamEncoder *compressor = new Cls(writer, type, speed); \
         return compressor; \
     } \
     static StreamCompressorHelper RG_UNIQUE_NAME(CreateCompressorHelper)((Type), RG_UNIQUE_NAME(CreateCompressor))
@@ -4934,6 +4867,36 @@ bool OptionToEnum(Span<const OptionDesc> options, Span<const char> str, T *out_v
     return false;
 }
 
+template <typename T>
+bool OptionToEnumI(Span<const char *const> options, Span<const char> str, T *out_value)
+{
+    for (Size i = 0; i < options.len; i++) {
+        const char *opt = options[i];
+
+        if (TestStrI(opt, str)) {
+            *out_value = (T)i;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+template <typename T>
+bool OptionToEnumI(Span<const OptionDesc> options, Span<const char> str, T *out_value)
+{
+    for (Size i = 0; i < options.len; i++) {
+        const OptionDesc &desc = options[i];
+
+        if (TestStrI(desc.name, str)) {
+            *out_value = (T)i;
+            return true;
+        }
+    }
+
+    return false;
+}
+
 template <typename T>
 bool OptionToFlag(Span<const char *const> options, Span<const char> str, T *out_flags, bool enable = true)
 {
@@ -4964,6 +4927,36 @@ bool OptionToFlag(Span<const OptionDesc> options, Span<const char> str, T *out_f
     return false;
 }
 
+template <typename T>
+bool OptionToFlagI(Span<const char *const> options, Span<const char> str, T *out_flags, bool enable = true)
+{
+    for (Size i = 0; i < options.len; i++) {
+        const char *opt = options[i];
+
+        if (TestStrI(opt, str)) {
+            *out_flags = ApplyMask(*out_flags, 1u << i, enable);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+template <typename T>
+bool OptionToFlagI(Span<const OptionDesc> options, Span<const char> str, T *out_flags, bool enable = true)
+{
+    for (Size i = 0; i < options.len; i++) {
+        const OptionDesc &desc = options[i];
+
+        if (TestStrI(desc.name, str)) {
+            *out_flags = ApplyMask(*out_flags, 1u << i, enable);
+            return true;
+        }
+    }
+
+    return false;
+}
+
 // ------------------------------------------------------------------------
 // Console prompter (simplified readline)
 // ------------------------------------------------------------------------

package/src/core/libcc/lz4.cc

@@ -27,7 +27,7 @@
 
 namespace RG {
 
-class LZ4Decompressor: public StreamDecompressor {
+class LZ4Decompressor: public StreamDecoder {
     LZ4F_dctx *decoder = nullptr;
     bool done = false;
 
@@ -39,25 +39,23 @@ class LZ4Decompressor: public StreamDecompressor {
     Size out_len = 0;
 
 public:
-    LZ4Decompressor(StreamReader *reader) : StreamDecompressor(reader) {}
+    LZ4Decompressor(StreamReader *reader, CompressionType type);
     ~LZ4Decompressor();
 
-    bool Init(CompressionType type) override;
     Size Read(Size max_len, void *out_buf) override;
 };
 
-LZ4Decompressor::~LZ4Decompressor()
-{
-    LZ4F_freeDecompressionContext(decoder);
-}
-
-bool LZ4Decompressor::Init(CompressionType)
+LZ4Decompressor::LZ4Decompressor(StreamReader *reader, CompressionType)
+    : StreamDecoder(reader) 
 {
     LZ4F_errorCode_t err = LZ4F_createDecompressionContext(&decoder, LZ4F_VERSION);
     if (LZ4F_isError(err))
         throw std::bad_alloc();
+}
 
-    return true;
+LZ4Decompressor::~LZ4Decompressor()
+{
+    LZ4F_freeDecompressionContext(decoder);
 }
 
 Size LZ4Decompressor::Read(Size max_len, void *user_buf)
@@ -106,27 +104,22 @@ Size LZ4Decompressor::Read(Size max_len, void *user_buf)
     RG_UNREACHABLE();
 }
 
-class LZ4Compressor: public StreamCompressor {
+class LZ4Compressor: public StreamEncoder {
     LZ4F_cctx *encoder = nullptr;
     LZ4F_preferences_t prefs = {};
 
     HeapArray<uint8_t> dynamic_buf;
 
 public:
-    LZ4Compressor(StreamWriter *writer) : StreamCompressor(writer) {}
+    LZ4Compressor(StreamWriter *writer, CompressionType type, CompressionSpeed speed);
     ~LZ4Compressor();
 
-    bool Init(CompressionType type, CompressionSpeed speed) override;
     bool Write(Span<const uint8_t> buf) override;
     bool Finalize() override;
 };
 
-LZ4Compressor::~LZ4Compressor()
-{
-    LZ4F_freeCompressionContext(encoder);
-}
-
-bool LZ4Compressor::Init(CompressionType, CompressionSpeed speed)
+LZ4Compressor::LZ4Compressor(StreamWriter *writer, CompressionType, CompressionSpeed speed)
+    : StreamEncoder(writer)
 {
     LZ4F_errorCode_t err = LZ4F_createCompressionContext(&encoder, LZ4F_VERSION);
     if (LZ4F_isError(err))
@@ -141,15 +134,15 @@ bool LZ4Compressor::Init(CompressionType, CompressionSpeed speed)
     dynamic_buf.Grow(LZ4F_HEADER_SIZE_MAX);
 
     size_t ret = LZ4F_compressBegin(encoder, dynamic_buf.end(), dynamic_buf.capacity - dynamic_buf.len, &prefs);
-
-    if (LZ4F_isError(ret)) {
-        LogError("Failed to start LZ4 stream for '%1': %2", GetFileName(), LZ4F_getErrorName(ret));
-        return false;
-    }
+    if (LZ4F_isError(ret))
+        throw std::bad_alloc();
 
     dynamic_buf.len += ret;
+}
 
-    return true;
+LZ4Compressor::~LZ4Compressor()
+{
+    LZ4F_freeCompressionContext(encoder);
 }
 
 bool LZ4Compressor::Write(Span<const uint8_t> buf)

package/src/core/libcc/miniz.cc

@@ -26,7 +26,7 @@
 
 namespace RG {
 
-class MinizDecompressor: public StreamDecompressor {
+class MinizDecompressor: public StreamDecoder {
     tinfl_decompressor inflator;
     bool done = false;
 
@@ -45,21 +45,19 @@ class MinizDecompressor: public StreamDecompressor {
     Size uncompressed_size = 0;
 
 public:
-    MinizDecompressor(StreamReader *reader) : StreamDecompressor(reader) {}
+    MinizDecompressor(StreamReader *reader, CompressionType type);
     ~MinizDecompressor() {}
 
-    bool Init(CompressionType type) override;
     Size Read(Size max_len, void *out_buf) override;
 };
 
-bool MinizDecompressor::Init(CompressionType type)
+MinizDecompressor::MinizDecompressor(StreamReader *reader, CompressionType type)
+    : StreamDecoder(reader)
 {
     static_assert(RG_SIZE(out_buf) >= TINFL_LZ_DICT_SIZE);
 
     tinfl_init(&inflator);
     is_gzip = (type == CompressionType::Gzip);
-
-    return true;
 }
 
 Size MinizDecompressor::Read(Size max_len, void *user_buf)
@@ -217,7 +215,7 @@ truncated_error:
     return -1;
 }
 
-class MinizCompressor: public StreamCompressor {
+class MinizCompressor: public StreamEncoder {
     tdefl_compressor deflator;
 
     // Gzip support
@@ -229,10 +227,9 @@ class MinizCompressor: public StreamCompressor {
     LocalArray<uint8_t, 1024> small_buf;
 
 public:
-    MinizCompressor(StreamWriter *writer) : StreamCompressor(writer) {}
+    MinizCompressor(StreamWriter *writer, CompressionType type, CompressionSpeed speed);
     ~MinizCompressor() {}
 
-    bool Init(CompressionType type, CompressionSpeed speed) override;
     bool Write(Span<const uint8_t> buf) override;
     bool Finalize() override;
 
@@ -240,7 +237,8 @@ private:
     bool WriteDeflate(Span<const uint8_t> buf);
 };
 
-bool MinizCompressor::Init(CompressionType type, CompressionSpeed speed)
+MinizCompressor::MinizCompressor(StreamWriter *writer, CompressionType type, CompressionSpeed speed)
+    : StreamEncoder(writer)
 {
     is_gzip = (type == CompressionType::Gzip);
 
@@ -256,10 +254,7 @@ bool MinizCompressor::Init(CompressionType type, CompressionSpeed speed)
         MinizCompressor *compressor = (MinizCompressor *)udata;
         return (int)compressor->WriteRaw(MakeSpan((uint8_t *)buf, len));
     }, this, flags);
-    if (status != TDEFL_STATUS_OKAY) {
-        LogError("Failed to initialize Deflate compression for '%1'", GetFileName());
-        return false;
-    }
+    RG_ASSERT(status == TDEFL_STATUS_OKAY);
 
     if (is_gzip) {
         static uint8_t gzip_header[] = {
@@ -271,11 +266,8 @@ bool MinizCompressor::Init(CompressionType type, CompressionSpeed speed)
             0           // OS
         };
 
-        if (!WriteRaw(gzip_header))
-            return false;
+        WriteRaw(gzip_header);
     }
-
-    return true;
 }
 
 bool MinizCompressor::Write(Span<const uint8_t> buf)