test: refine logging.

test/log.cc

@@ -14,13 +14,15 @@
 
 #include "test.h"
 
+static void fflushall() { fflush(nullptr); }
+
 void failure(const char *fmt, ...) {
   va_list ap;
   fflush(NULL);
   va_start(ap, fmt);
-  loggging::output(loggging::failure, fmt, ap);
+  logging::output(logging::failure, fmt, ap);
   va_end(ap);
-  fflush(NULL);
+  fflushall();
   exit(EXIT_FAILURE);
 }
 
@@ -35,10 +37,12 @@ void __noreturn failure_perror(const char *what, int errnum) {
 
 //-----------------------------------------------------------------------------
 
-namespace loggging {
+namespace logging {
 
 static std::string prefix;
+static std::string suffix;
 static loglevel level;
+static FILE *last;
 
 void setup(loglevel _level, const std::string &_prefix) {
   level = (_level > error) ? failure : _level;
@@ -68,61 +72,123 @@ const char *level2str(const loglevel level) {
 
 void output(loglevel priority, const char *format, va_list ap) {
   if (priority >= level) {
-    FILE *out = (priority >= error) ? stderr : stdout;
-    fprintf(out, "[ %u %-10s %6s ] " /* TODO */, osal_getpid(), prefix.c_str(),
-            level2str(priority));
-    vfprintf(out, format, ap);
+    last = (priority >= error) ? stderr : stdout;
+    fprintf(last, "[ %u %-10s %6s ] %s" /* TODO */, osal_getpid(),
+            prefix.c_str(), level2str(priority), suffix.c_str());
+    vfprintf(last, format, ap);
+
     size_t len = strlen(format);
-    if (len && format[len - 1] != '\n')
-      putc('\n', out);
+    char end = len ? format[len - 1] : '\0';
+    switch (end) {
+    default:
+      putc('\n', last);
+    case '\n':
+      if (priority > info)
+        fflushall();
+      break;
+    case ' ':
+    case '_':
+    case ':':
+    case '|':
+    case ',':
+    case '\t':
+    case '\b':
+    case '\r':
+    case '\0':
+      return;
+    }
+  }
+  last = nullptr;
+}
+
+void feed(const char *format, ...) {
+  if (last) {
+    va_list ap;
+    va_start(ap, format);
+    vfprintf(last, format, ap);
+    va_end(ap);
+
+    size_t len = strlen(format);
+    if (len && format[len - 1] == '\n')
+      last = nullptr;
   }
 }
 
+local_suffix::local_suffix(const char *c_str)
+    : trim_pos(suffix.size()), indent(0) {
+  suffix.append(c_str);
+}
+
+local_suffix::local_suffix(const std::string &str)
+    : trim_pos(suffix.size()), indent(0) {
+  suffix.append(str);
+}
+
+void local_suffix::push() {
+  indent += 1;
+  suffix.push_back('\t');
+}
+
+void local_suffix::pop() {
+  assert(indent > 0);
+  if (indent > 0) {
+    indent -= 1;
+    suffix.pop_back();
+  }
+}
+
+local_suffix::~local_suffix() { suffix.erase(trim_pos); }
+
 } /* namespace log */
 
 void log_trace(const char *msg, ...) {
-  if (loggging::trace >= loggging::level) {
+  if (logging::trace >= logging::level) {
     va_list ap;
     va_start(ap, msg);
-    loggging::output(loggging::trace, msg, ap);
+    logging::output(logging::trace, msg, ap);
     va_end(ap);
-  }
+  } else
+    logging::last = nullptr;
 }
 
 void log_info(const char *msg, ...) {
-  if (loggging::info >= loggging::level) {
+  if (logging::info >= logging::level) {
     va_list ap;
     va_start(ap, msg);
-    loggging::output(loggging::info, msg, ap);
+    logging::output(logging::info, msg, ap);
     va_end(ap);
-  }
+  } else
+    logging::last = nullptr;
 }
 
 void log_notice(const char *msg, ...) {
-  if (loggging::notice >= loggging::level) {
+  if (logging::notice >= logging::level) {
     va_list ap;
     va_start(ap, msg);
-    loggging::output(loggging::notice, msg, ap);
+    logging::output(logging::notice, msg, ap);
     va_end(ap);
-  }
+  } else
+    logging::last = nullptr;
 }
 
 void log_warning(const char *msg, ...) {
-  if (loggging::warning >= loggging::level) {
+  if (logging::warning >= logging::level) {
     va_list ap;
     va_start(ap, msg);
-    loggging::output(loggging::warning, msg, ap);
+    logging::output(logging::warning, msg, ap);
     va_end(ap);
-  }
+  } else
+    logging::last = nullptr;
 }
 
 void log_error(const char *msg, ...) {
-  if (loggging::error >= loggging::level) {
+  if (logging::error >= logging::level) {
     va_list ap;
     va_start(ap, msg);
-    loggging::output(loggging::error, msg, ap);
+    logging::output(logging::error, msg, ap);
     va_end(ap);
-  }
+  } else
+    logging::last = nullptr;
 }
 
 void log_touble(const char *where, const char *what, int errnum) {