Add diagnostics facility

5 files changed, 295 insertions, 4 deletions

diff --git a/butl/buildfile b/butl/buildfile
index fcb5f86..1607e7d 100644
--- a/butl/buildfile
+++ b/butl/buildfile
@@ -5,6 +5,7 @@
 lib{butl}:                               \
 {hxx         cxx}{ base64              } \
 {hxx         cxx}{ char-scanner        } \
+{hxx         cxx}{ diagnostics         } \
 {hxx            }{ export              } \
 {hxx ixx     cxx}{ fdstream            } \
 {hxx ixx     cxx}{ filesystem          } \
@@ -23,7 +24,7 @@ lib{butl}:                               \
 {hxx     txx    }{ string-table        } \
 {hxx         cxx}{ timestamp           } \
 {hxx         cxx}{ triplet             } \
-{hxx ixx        }{ utility             } \
+{hxx ixx     cxx}{ utility             } \
 {hxx            }{ vector-view         } \
 {hxx            }{ version             }
 
diff --git a/butl/diagnostics b/butl/diagnostics
new file mode 100644
index 0000000..77f3f9c
--- /dev/null
+++ b/butl/diagnostics
@@ -0,0 +1,198 @@
+// file      : butl/diagnostics -*- C++ -*-
+// copyright : Copyright (c) 2014-2016 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+#ifndef BUTL_DIAGNOSTICS
+#define BUTL_DIAGNOSTICS
+
+#include <cassert>
+#include <ostream>
+#include <sstream>
+#include <utility>   // move(), forward()
+#include <exception> // uncaught_exception()
+
+#include <butl/utility>
+
+namespace butl
+{
+  // Diagnostic facility base infrastructure.
+  //
+  extern std::ostream* diag_stream; // std::cerr by default.
+
+  struct diag_record;
+  template <typename> struct diag_prologue;
+  template <typename> struct diag_mark;
+
+  using diag_epilogue = void (const diag_record&);
+
+  struct diag_record
+  {
+    template <typename T>
+    friend const diag_record&
+    operator<< (const diag_record& r, const T& x)
+    {
+      r.os << x;
+      return r;
+    }
+
+    diag_record (): empty_ (true), epilogue_ (nullptr) {}
+
+    template <typename B>
+    explicit
+    diag_record (const diag_prologue<B>& p)
+        : empty_ (true), epilogue_ (nullptr) { *this << p;}
+
+    template <typename B>
+    explicit
+    diag_record (const diag_mark<B>& m)
+        : empty_ (true), epilogue_ (nullptr) { *this << m;}
+
+    ~diag_record () noexcept (false);
+
+    bool
+    empty () const {return empty_;}
+
+    bool
+    full () const {return !empty_;}
+
+    void
+    flush () const;
+
+    void
+    append (diag_epilogue* e) const
+    {
+      if (e != nullptr)
+      {
+        assert (epilogue_ == nullptr); // No multiple epilogues support.
+        epilogue_ = e;
+      }
+
+      if (empty_)
+        empty_ = false;
+      else
+        os << "\n  ";
+    }
+
+    // Move constructible-only type.
+    //
+    // Older versions of libstdc++ don't have the ostringstream move support
+    // and accuratly detecting its version is non-trivial. So we always use
+    // the pessimized implementation with libstdc++. Luckily, GCC doesn't seem
+    // to be needing move due to copy/move elision.
+    //
+#ifdef __GLIBCXX__
+    diag_record (diag_record&&);
+#else
+    diag_record (diag_record&& r)
+#ifndef __GLIBCXX__
+        : os (std::move (r.os))
+#endif
+    {
+      empty_ = r.empty_;
+      epilogue_ = r.epilogue_;
+
+      if (!empty_)
+      {
+#ifdef __GLIBCXX__
+        // os << r.os.str ();
+        assert (false); // No way to copy extra stream data?
+#endif
+        r.empty_ = true;
+        r.epilogue_ = nullptr;
+      }
+    }
+#endif
+
+    diag_record& operator= (diag_record&&) = delete;
+
+    diag_record (const diag_record&) = delete;
+    diag_record& operator= (const diag_record&) = delete;
+
+  public:
+    mutable std::ostringstream os;
+
+  protected:
+    mutable bool empty_;
+    mutable diag_epilogue* epilogue_;
+  };
+
+  template <typename B>
+  struct diag_prologue: B
+  {
+    diag_prologue (diag_epilogue* e = nullptr): B (), epilogue_ (e) {}
+
+    template <typename... A>
+    diag_prologue (A&&... a)
+        : B (std::forward<A> (a)...), epilogue_ (nullptr) {}
+
+    template <typename... A>
+    diag_prologue (diag_epilogue* e, A&&... a)
+        : B (std::forward<A> (a)...), epilogue_ (e) {}
+
+    template <typename T>
+    diag_record
+    operator<< (const T& x) const
+    {
+      diag_record r;
+      r.append (epilogue_);
+      B::operator() (r);
+      r << x;
+      return r;
+    }
+
+    friend const diag_record&
+    operator<< (const diag_record& r, const diag_prologue& p)
+    {
+      r.append (p.epilogue_);
+      p (r);
+      return r;
+    }
+
+  private:
+    diag_epilogue* epilogue_;
+  };
+
+  template <typename B>
+  struct diag_mark: B
+  {
+    diag_mark (): B () {}
+
+    template <typename... A>
+    diag_mark (A&&... a): B (std::forward<A> (a)...) {}
+
+    template <typename T>
+    diag_record
+    operator<< (const T& x) const
+    {
+      return B::operator() () << x;
+    }
+
+    friend const diag_record&
+    operator<< (const diag_record& r, const diag_mark& m)
+    {
+      return r << m ();
+    }
+  };
+
+  template <typename B>
+  struct diag_noreturn_end: B
+  {
+    diag_noreturn_end (): B () {}
+
+    template <typename... A>
+    diag_noreturn_end (A&&... a): B (std::forward<A> (a)...) {}
+
+    [[noreturn]] friend void
+    operator<< (const diag_record& r, const diag_noreturn_end& e)
+    {
+      // We said that we never return which means this end mark cannot be used
+      // to "maybe not return". And not returning without any diagnostics is
+      // probably a mistake.
+      //
+      assert (r.full ());
+      e.B::operator() (r);
+    }
+  };
+}
+
+#endif // BUTL_DIAGNOSTICS
diff --git a/butl/diagnostics.cxx b/butl/diagnostics.cxx
new file mode 100644
index 0000000..e4c22dc
--- /dev/null
+++ b/butl/diagnostics.cxx
@@ -0,0 +1,41 @@
+// file      : butl/diagnostics.cxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2016 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+#include <butl/diagnostics>
+
+#include <iostream> // cerr
+
+using namespace std;
+
+namespace butl
+{
+  ostream* diag_stream = &cerr;
+
+  void diag_record::
+  flush () const
+  {
+    if (!empty_)
+    {
+      *diag_stream << os.str () << endl;
+      empty_ = true;
+
+      if (epilogue_ != nullptr)
+        epilogue_ (*this); // Can throw.
+    }
+  }
+
+  diag_record::
+  ~diag_record () noexcept (false)
+  {
+    // Don't flush the record if this destructor was called as part of
+    // the stack unwinding. Right now this means we cannot use this
+    // mechanism in destructors, which is not a big deal, except for
+    // one place: exception_guard. So for now we are going to have
+    // this ugly special check which we will be able to get rid of
+    // once C++17 uncaught_exceptions() becomes available.
+    //
+    if (!std::uncaught_exception () || exception_unwinding_dtor)
+      flush ();
+  }
+}
diff --git a/butl/utility b/butl/utility
index a513325..6155207 100644
--- a/butl/utility
+++ b/butl/utility
@@ -6,9 +6,10 @@
 #define BUTL_UTILITY
 
 #include <string>
-#include <cstddef>    // size_t
-#include <utility>    // forward()
-#include <cstring>    // strcmp(), strlen()
+#include <cstddef>      // size_t
+#include <utility>      // move(), forward()
+#include <cstring>      // strcmp(), strlen()
+#include <exception>    // uncaught_exception()
 //#include <functional> // hash
 
 namespace butl
@@ -146,6 +147,46 @@ namespace butl
   template <typename T>
   inline reverse_range<T>
   reverse_iterate (T&& x) {return reverse_range<T> (std::forward<T> (x));}
+
+  // Call a function if there is an exception.
+  //
+
+  // True means we are in the body of a destructor that is being called as
+  // part of the exception stack unwindining. Used to compensate for the
+  // deficiencies of uncaught_exception() until C++17 uncaught_exceptions()
+  // becomes available.
+  //
+  // @@ MT: will have to be TLS.
+  //
+  extern bool exception_unwinding_dtor;
+
+  template <typename F>
+  struct exception_guard;
+
+  template <typename F>
+  inline exception_guard<F>
+  make_exception_guard (F f)
+  {
+    return exception_guard<F> (std::move (f));
+  }
+
+  template <typename F>
+  struct exception_guard
+  {
+    exception_guard (F f): f_ (std::move (f)) {}
+    ~exception_guard ()
+    {
+      if (std::uncaught_exception ())
+      {
+        exception_unwinding_dtor = true;
+        f_ ();
+        exception_unwinding_dtor = false;
+      }
+    }
+
+  private:
+    F f_;
+  };
 }
 
 #include <butl/utility.ixx>
diff --git a/butl/utility.cxx b/butl/utility.cxx
new file mode 100644
index 0000000..d6f418c
--- /dev/null
+++ b/butl/utility.cxx
@@ -0,0 +1,10 @@
+// file      : butl/utility.cxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2016 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+#include <butl/utility>
+
+namespace butl
+{
+  bool exception_unwinding_dtor = false;
+}