koffi 2.7.1 → 2.7.3

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;
     }