[base] Further improve the logging facility.

src/base/logging.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/base/logging.h"
 
 #if V8_LIBC_GLIBC || V8_OS_BSD
 # include <cxxabi.h>
 # include <execinfo.h>
 #elif V8_OS_QNX
 # include <backtrace.h>
 #endif  // V8_LIBC_GLIBC || V8_OS_BSD
 
 #include <cstdio>
 #include <cstdlib>
 
 #include "src/base/platform/platform.h"
 
 namespace v8 {
 namespace base {
+namespace logging {
 
 // Explicit instantiations for commonly used comparisons.
 #define DEFINE_MAKE_CHECK_OP_STRING(type)              \
   template std::string* MakeCheckOpString<type, type>( \
       type const&, type const&, char const*);
 DEFINE_MAKE_CHECK_OP_STRING(int)
 DEFINE_MAKE_CHECK_OP_STRING(long)       // NOLINT(runtime/int)
 DEFINE_MAKE_CHECK_OP_STRING(long long)  // NOLINT(runtime/int)
 DEFINE_MAKE_CHECK_OP_STRING(unsigned int)
 DEFINE_MAKE_CHECK_OP_STRING(unsigned long)       // NOLINT(runtime/int)
 DEFINE_MAKE_CHECK_OP_STRING(unsigned long long)  // NOLINT(runtime/int)
 DEFINE_MAKE_CHECK_OP_STRING(char const*)
 DEFINE_MAKE_CHECK_OP_STRING(void const*)
 #undef DEFINE_MAKE_CHECK_OP_STRING
 
 
 // Explicit instantiations for floating point checks.
-#define DEFINE_CHECK_OP_IMPL(NAME)                          \
-  template std::string* Check##NAME##Impl<float, float>(    \
-      float const& lhs, float const& rhs, char const* msg); \
-  template std::string* Check##NAME##Impl<double, double>(  \
-      double const& lhs, double const& rhs, char const* msg);
+#define DEFINE_CHECK_OP_IMPL(NAME)                             \
+  template std::string* Check##NAME##Impl<float, float>(       \
+      float const& lhs, float const& rhs, char const* result); \
+  template std::string* Check##NAME##Impl<double, double>(     \
+      double const& lhs, double const& rhs, char const* result);
 DEFINE_CHECK_OP_IMPL(EQ)
 DEFINE_CHECK_OP_IMPL(NE)
 DEFINE_CHECK_OP_IMPL(LE)
 DEFINE_CHECK_OP_IMPL(LT)
 DEFINE_CHECK_OP_IMPL(GE)
 DEFINE_CHECK_OP_IMPL(GT)
 #undef DEFINE_CHECK_OP_IMPL
 
 
+LogMessage::LogMessage(char const* file, int line, LogSeverity severity)
+    : file_(file), line_(line), severity_(severity) {}
+
+
+LogMessage::LogMessage(char const* file, int line, std::string* result)
+    : LogMessage(file, line, LOG_FATAL, result) {}
+
+
+LogMessage::LogMessage(char const* file, int line, LogSeverity severity,
+                       std::string* result)
+    : LogMessage(file, line, severity) {
+  stream() << "Check failed: " << *result;
+  delete result;
+}
+
+
+LogMessage::~LogMessage() {
+  if (severity_ == LOG_FATAL) {
+    V8_Fatal(file_, line_, "%s", stream_.str().c_str());
+  }
+  OS::Print("%s\n", stream_.str().c_str());
+}
+
+
+namespace {
+
 // Attempts to dump a backtrace (if supported).
+// TODO(bmeurer): Inline this thing into the caller!
 void DumpBacktrace() {
 #if V8_LIBC_GLIBC || V8_OS_BSD
   void* trace[100];
   int size = backtrace(trace, arraysize(trace));
   char** symbols = backtrace_symbols(trace, size);
   OS::PrintError("\n==== C stack trace ===============================\n\n");
   if (size == 0) {
     OS::PrintError("(empty)\n");
   } else if (symbols == NULL) {
     OS::PrintError("(no symbols)\n");
@@ skipping 29 matching lines @@
   } else {
     bt_sprnf_addrs(&memmap, trace, size, const_cast<char*>("%a\n"),
                    out, sizeof(out), NULL);
     OS::PrintError(out);
   }
   bt_unload_memmap(&memmap);
   bt_release_accessor(&acc);
 #endif  // V8_LIBC_GLIBC || V8_OS_BSD
 }
 
+}  // namespace
+
+}  // namespace logging
 }  // namespace base
 }  // namespace v8
 
 
 // Contains protection against recursive calls (faults while handling faults).
 extern "C" void V8_Fatal(const char* file, int line, const char* format, ...) {
   fflush(stdout);
   fflush(stderr);
   v8::base::OS::PrintError("\n\n#\n# Fatal error in %s, line %d\n# ", file,
                            line);
   va_list arguments;
   va_start(arguments, format);
   v8::base::OS::VPrintError(format, arguments);
   va_end(arguments);
   v8::base::OS::PrintError("\n#\n");
-  v8::base::DumpBacktrace();
+  v8::base::logging::DumpBacktrace();
   fflush(stderr);
   v8::base::OS::Abort();
 }