[all] debug: add multiline debug print variants

common/include/common/debug.h

@@ -74,6 +74,10 @@ void debug_level(enum DebugLevel level, const char * file, unsigned int line,
     const char * function, const char * format, ...)
   __attribute__((format (printf, 5, 6)));
 
+void debug_levelML(enum DebugLevel level, const char * file, unsigned int line,
+    const char * function, const char * format, ...)
+  __attribute__((format (printf, 5, 6)));
+
 void debug_info(const char * file, unsigned int line, const char * function,
     const char * format, ...) __attribute__((format (printf, 4, 5)));
 
@@ -113,12 +117,22 @@ void debug_trace(const char * file, unsigned int line, const char * function,
       fmt, ##__VA_ARGS__); \
 } while (0)
 
+#define DEBUG_PRINT_ML(level, fmt, ...) do { \
+  debug_levelML(level, STRIPPATH(__FILE__), __LINE__, __FUNCTION__, \
+      fmt, ##__VA_ARGS__); \
+} while (0)
+
 #define DEBUG_BREAK() DEBUG_PRINT(DEBUG_LEVEL_INFO, "================================================================================")
 #define DEBUG_INFO(fmt, ...) DEBUG_PRINT(DEBUG_LEVEL_INFO, fmt, ##__VA_ARGS__)
 #define DEBUG_WARN(fmt, ...) DEBUG_PRINT(DEBUG_LEVEL_WARN, fmt, ##__VA_ARGS__)
 #define DEBUG_ERROR(fmt, ...) DEBUG_PRINT(DEBUG_LEVEL_ERROR, fmt, ##__VA_ARGS__)
 #define DEBUG_TRACE(fmt, ...) DEBUG_PRINT(DEBUG_LEVEL_TRACE, fmt, ##__VA_ARGS__)
 #define DEBUG_FIXME(fmt, ...) DEBUG_PRINT(DEBUG_LEVEL_FIXME, fmt, ##__VA_ARGS__)
+#define DEBUG_INFO_ML(fmt, ...) DEBUG_PRINT_ML(DEBUG_LEVEL_INFO, fmt, ##__VA_ARGS__)
+#define DEBUG_WARN_ML(fmt, ...) DEBUG_PRINT_ML(DEBUG_LEVEL_WARN, fmt, ##__VA_ARGS__)
+#define DEBUG_ERROR_ML(fmt, ...) DEBUG_PRINT_ML(DEBUG_LEVEL_ERROR, fmt, ##__VA_ARGS__)
+#define DEBUG_TRACE_ML(fmt, ...) DEBUG_PRINT_ML(DEBUG_LEVEL_TRACE, fmt, ##__VA_ARGS__)
+#define DEBUG_FIXME_ML(fmt, ...) DEBUG_PRINT_ML(DEBUG_LEVEL_FIXME, fmt, ##__VA_ARGS__)
 #define DEBUG_FATAL(fmt, ...) do { \
   DEBUG_BREAK(); \
   DEBUG_PRINT(DEBUG_LEVEL_FATAL, fmt, ##__VA_ARGS__); \
@@ -126,6 +140,13 @@ void debug_trace(const char * file, unsigned int line, const char * function,
   abort(); \
   DEBUG_UNREACHABLE_MARKER(); \
 } while(0)
+#define DEBUG_FATAL_ML(fmt, ...) do { \
+  DEBUG_BREAK(); \
+  DEBUG_PRINT_ML(DEBUG_LEVEL_FATAL, fmt, ##__VA_ARGS__); \
+  DEBUG_PRINT_BACKTRACE(); \
+  abort(); \
+  DEBUG_UNREACHABLE_MARKER(); \
+} while(0)
 
 #define DEBUG_ASSERT_PRINT(...) DEBUG_ERROR("Assertion failed: %s", #__VA_ARGS__)
 

common/src/debug.c

@@ -38,19 +38,15 @@ void debug_enableTracing(void)
   traceEnabled = true;
 }
 
-inline static void debug_levelVA(enum DebugLevel level, const char * file,
+inline static void debug_printPrefix(enum DebugLevel level, const char * file,
-    unsigned int line, const char * function, const char * format, va_list va)
+    unsigned int line, const char * function, uint64_t elapsed)
 {
-  if (level == DEBUG_LEVEL_TRACE && !traceEnabled)
-    return;
-
   const char * f = strrchr(file, DIRECTORY_SEPARATOR);
   if (!f)
     f = file;
   else
     ++f;
 
-  uint64_t elapsed = microtime() - startTime;
   uint64_t sec     = elapsed / 1000000UL;
   uint64_t us      = elapsed % 1000000UL;
 
@@ -62,11 +58,66 @@ inline static void debug_levelVA(enum DebugLevel level, const char * file,
       debug_lookup[level],
       f,
       line, function);
+}
 
+inline static void debug_levelVA(enum DebugLevel level, const char * file,
+    unsigned int line, const char * function, const char * format, va_list va)
+{
+  if (level == DEBUG_LEVEL_TRACE && !traceEnabled)
+    return;
+
+  debug_printPrefix(level, file, line, function, microtime() - startTime);
   vfprintf(stderr, format, va);
   fprintf(stderr, "%s\n", debug_lookup[DEBUG_LEVEL_NONE]);
 }
 
+inline static void debug_levelMLVA(enum DebugLevel level, const char * file,
+    unsigned int line, const char * function, const char * format, va_list va)
+{
+  if (level == DEBUG_LEVEL_TRACE && !traceEnabled)
+    return;
+
+  va_list copy;
+  va_copy(copy, va);
+  int length = vsnprintf(NULL, 0, format, copy);
+  va_end(copy);
+  if (length < 0)
+    return;
+
+  char * message = malloc((size_t)length + 1);
+  if (!message)
+    return;
+
+  va_copy(copy, va);
+  int result = vsnprintf(message, (size_t)length + 1, format, copy);
+  va_end(copy);
+  if (result < 0)
+  {
+    free(message);
+    return;
+  }
+
+  const uint64_t elapsed = microtime() - startTime;
+  const char * start = message;
+  while (true)
+  {
+    const char * end = strchr(start, '\n');
+    size_t lineLength = end ? (size_t)(end - start) : strlen(start);
+    if (lineLength && start[lineLength - 1] == '\r')
+      --lineLength;
+
+    debug_printPrefix(level, file, line, function, elapsed);
+    fwrite(start, 1, lineLength, stderr);
+    fprintf(stderr, "%s\n", debug_lookup[DEBUG_LEVEL_NONE]);
+
+    if (!end || !end[1])
+      break;
+    start = end + 1;
+  }
+
+  free(message);
+}
+
 
 void debug_level(enum DebugLevel level, const char * file, unsigned int line,
     const char * function, const char * format, ...)
@@ -77,6 +128,15 @@ void debug_level(enum DebugLevel level, const char * file, unsigned int line,
   va_end(va);
 }
 
+void debug_levelML(enum DebugLevel level, const char * file, unsigned int line,
+    const char * function, const char * format, ...)
+{
+  va_list va;
+  va_start(va, format);
+  debug_levelMLVA(level, file, line, function, format, va);
+  va_end(va);
+}
+
 void debug_info(const char * file, unsigned int line, const char * function,
     const char * format, ...)
 {

idd/LGCommon/CDebug.cpp

@@ -161,13 +161,18 @@ void CDebug::Init(const wchar_t * name)
   m_stream = std::move(stream);
 }
 
-void CDebug::LogStr(CDebug::Level level, const char *function, int line, bool wide, const void *str)
+void CDebug::LogStr(CDebug::Level level, const char *function, int line, bool wide, const void *str,
+  const wchar_t *timestamp)
 {
   if (level < 0 || level >= LEVEL_MAX)
     level = LEVEL_NONE;
 
-  wchar_t timestamp[50];
+  wchar_t currentTimestamp[50];
-  iso8601(timestamp, ARRAYSIZE(timestamp));
+  if (!timestamp)
+  {
+    iso8601(currentTimestamp, ARRAYSIZE(currentTimestamp));
+    timestamp = currentTimestamp;
+  }
 
   wchar_t *result;
   if (aswprintf(&result, wide ? L"[%s] [%S] %40S:%-4d | %s\n" : L"[%s] [%S] %40S:%-4d | %S\n",
@@ -202,6 +207,47 @@ void CDebug::Log(CDebug::Level level, const char *function, int line, const char
   va_end(args);
 }
 
+void CDebug::LogML_va(CDebug::Level level, const char *function, int line, const char *fmt, va_list args)
+{
+  char *result;
+  if (vasprintf(&result, fmt, args) < 0)
+  {
+    Write(L"Out of memory while logging");
+    return;
+  }
+
+  wchar_t timestamp[50];
+  iso8601(timestamp, ARRAYSIZE(timestamp));
+
+  char *start = result;
+  while (true)
+  {
+    char *end = strchr(start, '\n');
+    if (end)
+      *end = '\0';
+
+    size_t length = strlen(start);
+    if (length && start[length - 1] == '\r')
+      start[length - 1] = '\0';
+
+    LogStr(level, function, line, false, start, timestamp);
+
+    if (!end || !end[1])
+      break;
+    start = end + 1;
+  }
+
+  free(result);
+}
+
+void CDebug::LogML(CDebug::Level level, const char *function, int line, const char *fmt, ...)
+{
+  va_list args;
+  va_start(args, fmt);
+  LogML_va(level, function, line, fmt, args);
+  va_end(args);
+}
+
 void CDebug::Log_va(CDebug::Level level, const char *function, int line, const wchar_t *fmt, va_list args)
 {
   wchar_t *result;
@@ -223,6 +269,47 @@ void CDebug::Log(CDebug::Level level, const char *function, int line, const wcha
   va_end(args);
 }
 
+void CDebug::LogML_va(CDebug::Level level, const char *function, int line, const wchar_t *fmt, va_list args)
+{
+  wchar_t *result;
+  if (vaswprintf(&result, fmt, args) < 0)
+  {
+    Write(L"Out of memory while logging");
+    return;
+  }
+
+  wchar_t timestamp[50];
+  iso8601(timestamp, ARRAYSIZE(timestamp));
+
+  wchar_t *start = result;
+  while (true)
+  {
+    wchar_t *end = wcschr(start, L'\n');
+    if (end)
+      *end = L'\0';
+
+    size_t length = wcslen(start);
+    if (length && start[length - 1] == L'\r')
+      start[length - 1] = L'\0';
+
+    LogStr(level, function, line, true, start, timestamp);
+
+    if (!end || !end[1])
+      break;
+    start = end + 1;
+  }
+
+  free(result);
+}
+
+void CDebug::LogML(CDebug::Level level, const char *function, int line, const wchar_t *fmt, ...)
+{
+  va_list args;
+  va_start(args, fmt);
+  LogML_va(level, function, line, fmt, args);
+  va_end(args);
+}
+
 void CDebug::LogStrHR(CDebug::Level level, HRESULT hr, const char *function, int line, bool wide, const void *str)
 {
   wchar_t *hrBuffer;

idd/LGCommon/CDebug.h

@@ -51,11 +51,16 @@ class CDebug
     void Log(CDebug::Level level, const char *function, int line, const wchar_t *fmt, ...);
     void Log_va(CDebug::Level level, const char *function, int line, const char *fmt, va_list args);
     void Log(CDebug::Level level, const char *function, int line, const char *fmt, ...);
+    void LogML_va(CDebug::Level level, const char *function, int line, const wchar_t *fmt, va_list args);
+    void LogML(CDebug::Level level, const char *function, int line, const wchar_t *fmt, ...);
+    void LogML_va(CDebug::Level level, const char *function, int line, const char *fmt, va_list args);
+    void LogML(CDebug::Level level, const char *function, int line, const char *fmt, ...);
     void LogHR(CDebug::Level level, HRESULT hr, const char *function, int line, const char *fmt, ...);
     void LogHR(CDebug::Level level, HRESULT hr, const char *function, int line, const wchar_t *fmt, ...);
 
   private:
-    void LogStr(CDebug::Level level, const char *function, int line, bool wide, const void *str);
+    void LogStr(CDebug::Level level, const char *function, int line, bool wide, const void *str,
+      const wchar_t *timestamp = nullptr);
     void LogStrHR(CDebug::Level level, HRESULT hr, const char *function, int line, bool wide, const void *str);
     static const char *s_levelStr[LEVEL_MAX];
 };
@@ -69,6 +74,12 @@ extern CDebug g_debug;
 #define DEBUG_FIXME(fmt, ...) g_debug.Log(CDebug::LEVEL_FIXME, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__)
 #define DEBUG_FATAL(fmt, ...) g_debug.Log(CDebug::LEVEL_FATAL, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__)
 
+#define DEBUG_INFO_ML(fmt, ...) g_debug.LogML(CDebug::LEVEL_INFO, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__)
+#define DEBUG_WARN_ML(fmt, ...) g_debug.LogML(CDebug::LEVEL_WARN, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__)
+#define DEBUG_ERROR_ML(fmt, ...) g_debug.LogML(CDebug::LEVEL_ERROR, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__)
+#define DEBUG_TRACE_ML(fmt, ...) g_debug.LogML(CDebug::LEVEL_TRACE, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__)
+#define DEBUG_FIXME_ML(fmt, ...) g_debug.LogML(CDebug::LEVEL_FIXME, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__)
+#define DEBUG_FATAL_ML(fmt, ...) g_debug.LogML(CDebug::LEVEL_FATAL, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__)
 
 #define DEBUG_INFO_HR(hr, fmt, ...) g_debug.LogHR(CDebug::LEVEL_INFO, hr, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__)
 #define DEBUG_WARN_HR(hr, fmt, ...) g_debug.LogHR(CDebug::LEVEL_WARN, hr, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__)