koffi 2.7.0 → 2.7.2

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
@@ -3881,8 +3897,11 @@ bool CreateOverlappedPipe(bool overlap0, bool overlap1, PipeMode mode, HANDLE ou
 
 void CloseHandleSafe(HANDLE *handle_ptr)
 {
-    if (*handle_ptr && *handle_ptr != INVALID_HANDLE_VALUE) {
-        CloseHandle(*handle_ptr);
+    HANDLE h = *handle_ptr;
+
+    if (h && h != INVALID_HANDLE_VALUE) {
+        CancelIo(h);
+        CloseHandle(h);
     }
 
     *handle_ptr = nullptr;
@@ -4021,6 +4040,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
             CloseHandleSafe(&si.hStdOutput);
             CloseHandleSafe(&si.hStdError);
         };
+
         if (in_func.IsValid() || out_func.IsValid()) {
             if (!DuplicateHandle(GetCurrentProcess(), in_func.IsValid() ? in_pipe[0] : GetStdHandle(STD_INPUT_HANDLE),
                                  GetCurrentProcess(), &si.hStdInput, 0, TRUE, DUPLICATE_SAME_ACCESS)) {
@@ -4095,6 +4115,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                 if (proc_in.err && proc_in.err != ERROR_BROKEN_PIPE && proc_in.err != ERROR_NO_DATA) {
                     LogError("Failed to write to process: %1", GetWin32ErrorString(proc_in.err));
                 }
+
                 proc_in.pending = true;
             }
 
@@ -4111,30 +4132,23 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                     }
                 }
 
-                if (proc_out.err && proc_out.err != ERROR_BROKEN_PIPE && proc_out.err != ERROR_NO_DATA) {
-                    LogError("Failed to read process output: %1", GetWin32ErrorString(proc_out.err));
+                if (proc_out.err) {
+                    if (proc_out.err != ERROR_BROKEN_PIPE && proc_out.err != ERROR_NO_DATA) {
+                        LogError("Failed to read process output: %1", GetWin32ErrorString(proc_out.err));
+                    }
+                    break;
                 }
+
                 proc_out.pending = true;
             }
 
-            HANDLE events[2] = {
-                process_handle,
-                console_ctrl_event
-            };
-
-            running = (WaitForMultipleObjectsEx(RG_LEN(events), events, FALSE, INFINITE, TRUE) > WAIT_OBJECT_0 + 1);
+            running = (WaitForSingleObjectEx(console_ctrl_event, INFINITE, TRUE) != WAIT_OBJECT_0);
         }
     }
 
     // Terminate any remaining I/O
-    if (in_pipe[1]) {
-        CancelIo(in_pipe[1]);
-        CloseHandleSafe(&in_pipe[1]);
-    }
-    if (out_pipe[0]) {
-        CancelIo(out_pipe[0]);
-        CloseHandleSafe(&out_pipe[0]);
-    }
+    CloseHandleSafe(&in_pipe[1]);
+    CloseHandleSafe(&out_pipe[0]);
 
     // Wait for process exit
     {
@@ -6184,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)
 {
@@ -6288,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) {
@@ -6310,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;
@@ -6325,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: {
@@ -6341,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;
 
@@ -6378,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;
     }
@@ -6423,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;
@@ -6512,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;
 }
 
@@ -6623,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)
@@ -6804,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);
@@ -6819,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) {
@@ -6882,7 +6886,6 @@ bool StreamWriter::Close(bool implicit)
 
     filename = nullptr;
     error = true;
-    compression_type = CompressionType::None;
     dest.type = DestinationType::Memory;
     str_alloc.ReleaseAll();
 
@@ -6900,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;
 }
 
@@ -7015,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;
     }
 
@@ -7518,6 +7510,13 @@ void OptionParser::LogUnknownError() const
     }
 }
 
+void OptionParser::LogUnusedArguments() const
+{
+    if (pos < args.len) {
+       LogWarning("Unused command-line arguments");
+    }
+}
+
 // ------------------------------------------------------------------------
 // Console prompter (simplified readline)
 // ------------------------------------------------------------------------