DebugPrinter.hpp

Go to the documentation of this file.

// ToDo: constexpr DebugPrinter for compile-time debugging
//       when setting a "constexpr string" as output

#ifndef DEBUGPRINTER_HEADER
#define DEBUGPRINTER_HEADER

#include <iostream>

#ifdef NDEBUG
#define DEBUGPRINTER_OFF
#endif

#ifndef DEBUGPRINTER_OFF

#include <iomanip>
#include <fstream>
#include <sstream>
#include <typeinfo>
#include <cstdlib>
#include <algorithm>
#include <stdexcept>
#include <memory>
#include <type_traits>

#ifndef DEBUGPRINTER_NO_EXECINFO
#include <execinfo.h>
#endif // DEBUGPRINTER_NO_EXECINFO

#ifndef DEBUGPRINTER_NO_CXXABI
#include <cxxabi.h>
#endif // DEBUGPRINTER_NO_CXXABI

#ifndef DEBUGPRINTER_NO_SIGNALS
#include <signal.h>
#include <map>
#endif // DEBUGPRINTER_NO_SIGNALS

#if defined (WIN32) || defined (_WIN32)  // TODO: this can be improved a lot
#define DEBUGPRINTER_DIRSEP '\\'
#else
#define DEBUGPRINTER_DIRSEP '/'
#endif

#endif // DEBUGPRINTER_OFF

namespace fsc {

#ifndef DEBUGPRINTER_OFF

class DebugPrinter {

  public:

/*******************************************************************************
 * DebugPrinter ctor and friends
 */
 
  DebugPrinter() {

    operator=(std::cout);
    set_precision(5);
    set_color("0;31");

    #ifndef DEBUGPRINTER_NO_SIGNALS
    struct sigaction act;
    act.sa_handler = signal_handler;
    for(auto const & sig: sig_names()) {
        sigaction(sig.first, &act, NULL);
    }
    #endif // DEBUGPRINTER_NO_SIGNALS

  }

  DebugPrinter(const DebugPrinter &) = delete;

  DebugPrinter(DebugPrinter &&) = delete;

  template <typename T>
  friend inline DebugPrinter & operator<<(DebugPrinter &, const T&);

  friend inline DebugPrinter & operator<<(DebugPrinter &,
                                          std::ostream& (*pf)(std::ostream&));

/*******************************************************************************
 * DebugPrinter setters
 */

  inline void operator=(std::ostream & os) noexcept { outstream = &os; }

  template <typename T>
  inline auto operator=(T && os)
    ->  std::enable_if_t<std::is_move_assignable<T>::value
                      && std::is_rvalue_reference<decltype(os)>::value> {
    outstream_mm = std::shared_ptr<std::ostream>(new T(std::move(os)));
    outstream = outstream_mm.get();
  }

  inline void set_precision(const std::streamsize prec) noexcept { prec_ = prec; }

  inline void set_color(const std::string str) {  // no chaining <- returns void
    if(is_number(str.substr(0,1)) && is_number(str.substr(2,2))) {
      hcol_ = "\033[" + str + "m";
      hcol_r_ = "\033[0m";
    } else
      throw std::runtime_error("DebugPrinter error: invalid set_color() argument");
  }
  inline void set_color() noexcept {  // no chaining <- returns void
    hcol_ = "";
    hcol_r_ = "";
  }

/*******************************************************************************
 * DebugPrinter parentheses operators
 */

  template <typename T, typename U>
  inline void operator()(const T & label, U const & obj,
                         const std::string sc = ": ") const {
    print_stream_impl< has_stream<T> && has_stream<U> >(label, obj, sc);
  }
  template <typename T>
  inline void operator()(const T& obj) const { operator()(">>>", obj, " "); }

/*******************************************************************************
 * DebugPrinter info on type and RTTI (stack)
 */

  #ifndef DEBUGPRINTER_NO_EXECINFO

  void stack(
      const int backtrace_size = max_backtrace,
      const bool compact = false,
      const int begin = 1 /* should stay 1 except for special needs */
    ) const {

    std::ostream & out = *outstream;

    using uint = unsigned int;

    uint end = begin + backtrace_size;   // don't pull more than necessary
    if(end > max_backtrace)
      end = max_backtrace;

    void * stack[max_backtrace];
    uint r = backtrace(stack, end);
    if(end == max_backtrace)             // prettiness hack: ignore binary line
      --r;
    end = r;                             // update to received end
    char ** symbols = backtrace_symbols(stack, end);

    if(compact == false)
      out << "DebugPrinter obtained " << end-begin << " stack frames:"
          << std::endl;
    if(!symbols) return;

    #ifndef DEBUGPRINTER_NO_CXXABI

    for(uint i = begin; i < end; ++i) {
      std::string line = std::string(symbols[i]);
      std::string prog = prog_part(line);
      std::string mangled = mangled_part(line);
      std::string offset = offset_part(line);
      std::string mainoffset = address_part(line);
      if(mangled == "")
        std::cerr << "DebugPrinter error: No dynamic symbol (you probably didn't compile with -rdynamic)"
                  << std::endl;
      int status;
      std::string demangled = demangle(mangled, status);
      switch (status) {
        case -1:
          out << "DebugPrinter error: Could not allocate memory!" << std::endl;
          break;
        case -3:
          out << "DebugPrinter error: Invalid argument to demangle()" << std::endl;
          break;
        case -2:  // invalid name under the C++ ABI mangling rules
          demangled = mangled;
          // fallthrough
        default:
          if(compact == false)
            out << "  " << prog << ":  " << demangled << "\t+"
                << offset << "\t[+" << mainoffset << "]"<< std::endl;
          else
            out << demangled << std::endl;
      }
    }
    if(compact == false) out << std::endl;

    #else // DEBUGPRINTER_NO_CXXABI

    for(uint i = begin; i < end; ++i) {
      if(compact == false)
        out << "  " << symbols[i] << std::endl;
      else
        out << mangled_part(std::string(symbols[i])) << std::endl;
    }

    if(compact == false) out << std::endl;
    out << "echo '' && c++filt";
    for(uint i = begin; i < end; ++i)
      out << " " << mangled_part(std::string(symbols[i]));
    out << " && echo ''" << std::endl;
    if(compact == false) out << std::endl;

    #endif // DEBUGPRINTER_NO_CXXABI

    free(symbols);
  }

  #else // DEBUGPRINTER_NO_EXECINFO

  void stack(...) const {
    *outstream << "DebugPrinter::stack() not available" << std::endl;
  }

  #endif // DEBUGPRINTER_NO_EXECINFO

/*******************************************************************************
 * DebugPrinter "private" parts
 */
 
  struct detail {

    DebugPrinter & super;

    // Simulate method specialisation through overloading
    template<typename T> struct fwdtype {};

    // Specialisation for type printing, used through dout_TYPE and dout_TYPE_OF
    #define DEBUGPRINTER_TYPE_SPEC(mods)                                       \
    template <typename T>                                                      \
    inline void type(detail::fwdtype<T mods>,                                  \
                     const std::string valness = "",                           \
                     const std::string expr = "") const {                      \
      int dummy;                                                               \
      std::string info = "";                                                   \
      if(expr != "")                                                           \
        info = "  {" + valness + " " + expr + "}";                             \
      auto mod = super.mod_split(std::string(#mods));                          \
      super << mod.first << super.demangle(typeid(T).name(), dummy)            \
            << mod.second << info << std::endl;                                \
    }                                                                         //
    DEBUGPRINTER_TYPE_SPEC()
    DEBUGPRINTER_TYPE_SPEC(&)
    DEBUGPRINTER_TYPE_SPEC(&&)
    DEBUGPRINTER_TYPE_SPEC(const)
    DEBUGPRINTER_TYPE_SPEC(const &)
    DEBUGPRINTER_TYPE_SPEC(const &&)
    DEBUGPRINTER_TYPE_SPEC(volatile)
    DEBUGPRINTER_TYPE_SPEC(volatile &)
    DEBUGPRINTER_TYPE_SPEC(volatile &&)
    DEBUGPRINTER_TYPE_SPEC(const volatile)
    DEBUGPRINTER_TYPE_SPEC(const volatile &)
    DEBUGPRINTER_TYPE_SPEC(const volatile &&)
    #undef DEBUGPRINTER_TYPE_SPEC

    // Get valueness of provided variable
    template<typename T>
    const std::string valueness(T &&) const noexcept {
        return super.valueness_impl(fwdtype<T>());
    }

    // Was used to print types and vars through same iface, but loses cv + ref
    // We cannot implement a function like sizeof() and typeid() that takes
    // types and instances.
    // ToDo: or can we?
    //       try appending #def TYPE TYPE_IMPL(input x) and abuse comma split
    //       and typeid/sizeof for x
    inline void type_name(const std::string & name,
                          const std::string & traits = "") {
      int dummy;
      *(super.outstream) << traits << super.demangle(name, dummy) << std::endl;
    }

    inline void pause(std::string reason) const {
      if(reason != "") reason = " (" + reason + ")";
      std::cout << "DebugPrinter paused" << reason
                << ". Press ENTER to continue." << std::flush;
      std::cin.clear();
      std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
    template <typename T>
    static const T & pausecheck(const T & t) {
      return t;
    }
    static bool pausecheck() { return true; }

    inline std::string filemacro_name(const std::string str) const {
      return str.substr(str.rfind(DEBUGPRINTER_DIRSEP)+1);
    }

  } const detail_{*this};

/*******************************************************************************
 * DebugPrinter private parts
 */

  private:

  std::ostream * outstream;                      // output stream
  std::shared_ptr<std::ostream> outstream_mm;    // managed output stream
  std::streamsize prec_;                         // precision
  std::string hcol_;                             // highlighting color
  std::string hcol_r_;                           // neutral color

  static const unsigned int max_backtrace = 50;
  static const unsigned int max_demangled = 4096;

  #ifndef DEBUGPRINTER_NO_SIGNALS
  using sig_type = int;
  static std::map<sig_type, std::string> sig_names() {
    std::map<sig_type, std::string> res;
    res[SIGABRT] = "SIGABRT";
    res[SIGFPE] = "SIGFPE";
    res[SIGSEGV] = "SIGSEGV";
    res[SIGSYS] = "SIGSYS";
    return res;
  }
  //~ static DebugPrinter & static_init() { static DebugPrinter d; return d; }
  static void signal_handler(int signum) {
    static DebugPrinter d;
    d << "DebugPrinter handler caught signal "
      << sig_names()[signum] << " (" << signum << ")" << std::endl;
    //~ static_init().stack(max_backtrace, false, 3);
    d.stack(max_backtrace, false, 3);
    struct sigaction act;
    act.sa_handler = SIG_DFL;
    sigaction(signum, &act, NULL);
  }
  #endif // DEBUGPRINTER_NO_SIGNALS

  #ifndef DEBUGPRINTER_NO_CXXABI

  inline std::string demangle(const std::string & str, int & status) const {
    std::unique_ptr<char, void(*)(void*)>  // needs to call free, not delete
      dmgl(abi::__cxa_demangle(str.c_str(), 0, 0, &status), std::free);
    return (status==0) ? dmgl.get() : str;  // calls string ctor for char*
  }

  #else // DEBUGPRINTER_NO_CXXABI

  inline std::string demangle(const std::string & str, int &) const noexcept {
    return str;
  }

  #endif // DEBUGPRINTER_NO_CXXABI

  // Fetch different parts from a stack trace line
  #ifdef __APPLE__
  inline std::string prog_part(const std::string str) const {
    std::stringstream ss(str);
    std::string res;
    ss >> res; ss >> res;
    return res;
  }
  inline std::string mangled_part(const std::string str) const {
    std::stringstream ss(str);
    std::string res;
    ss >> res; ss >> res; ss >> res; ss >> res;
    return res;
  }
  inline std::string offset_part(const std::string str) const {
    std::stringstream ss(str);
    std::string res;
    ss >> res; ss >> res; ss >> res; ss >> res; ss >> res; ss >> res;
    return res;
  }
  inline std::string address_part(const std::string str) const {
    std::stringstream ss(str);
    std::string res;
    ss >> res; ss >> res; ss >> res;
    return res;
  }
  #else
  inline std::string prog_part(const std::string str) const {
    return str.substr(0, str.find("("));
  }
  inline std::string mangled_part(const std::string str) const {
    std::string::size_type pos = str.find("(") + 1;
    if(str.find("+", pos) == std::string::npos) return "";
    return str.substr(pos, str.find("+", pos) - pos);
  }
  inline std::string offset_part(const std::string str) const {
    std::string::size_type pos = str.find("+");
    if(pos == std::string::npos) return "";
    else return str.substr(pos+1, str.find(")", pos) - pos-1);
  }
  inline std::string address_part(const std::string str) const {
    std::string::size_type pos = str.find("[");
    if(pos == std::string::npos) return "";
    else return str.substr(pos+1, str.find("]", pos) - pos-1);
  }
  #endif

  // Used for set_color validation
  bool is_number(const std::string& s) const {
    return !s.empty() && std::find_if(s.begin(), s.end(),
                            [](char c) { return !std::isdigit(c); }) == s.end();
  }

  // Implementation of operator()
  template <bool B, typename U, typename V>
  std::enable_if_t<!B>
  print_stream_impl(const U& label, const V& obj, const std::string&) const {
    auto typ = [this](const auto & obj)  // careless (dummy) demangle wrapper
               { int dummy = 0; return demangle(typeid(obj).name(), dummy); };
    *outstream << "DebugPrinter error: object of type "
               << ( has_stream<U> ? typ(obj) : typ(label) ) << std::endl
               << "                    has no suitable " << typ(*outstream)
               << " operator<< overload." << std::endl;
  }
  template <bool B, typename U, typename V>
  std::enable_if_t<B>
  print_stream_impl(const U& label, const V& obj, const std::string& sc) const {
    *outstream << hcol_ << label << sc << obj
               << hcol_r_ << std::endl;
  }


  // ToDo: specialise on m_and (break on false before evaluating rest, faster compile)
  //       and use in print_stream_impl instead of has_stream && has_stream
  template <bool B, typename... T>
  struct m_and_impl {
    using type = std::integral_constant<bool , B>;
  };

  template <bool B, typename T, typename... U>
  struct m_and_impl<B, T, U...> {
    using type = typename m_and_impl<B && T::value, U...>::type;
  };
  template <typename... T>
  struct m_and : public m_and_impl<true, T...>::type {
  };

  template<typename T, typename S>
  struct has_stream_impl {
    template <typename T_, typename S_>
    static auto check(T_ && t, S_ && s) -> decltype(  // test for any expression:
      s << t,
    std::true_type());
    static std::false_type check(...);
    using type = decltype(check( std::declval<T>(), std::declval<S>()));
  };
  template<typename T, typename S = std::ostream&>
  struct has_stream_t : public has_stream_impl<T, S>::type {};  // ::type stl boolean has ::value
  template<typename T, typename S = std::ostream&>
  static constexpr bool has_stream = has_stream_impl<T, S>::type::value;

  

  // Used to split mods for type()/type_of()
  std::pair<std::string, std::string> mod_split(const std::string & s) const {
    auto pos = s.find('&');
    pos = pos==std::string::npos ? s.size() : pos;
    std::string first = s.substr(0, pos), second = s.substr(pos);

    if(first.size() > 0 && first.back()!= ' ') first += " ";
    if(second.size() > 0) second = " " + second;
    return std::make_pair(first, second);
  }

  // Used for valueness printing
  template <typename T>
  const std::string valueness_impl(detail::fwdtype<T>) const noexcept
    { return "r-value"; }
  template <typename T>
  const std::string valueness_impl(detail::fwdtype<T&>) const noexcept
    { return "l-value"; }

};

/*******************************************************************************
 * std::ostream overloads
 */

template <typename T>
DebugPrinter & operator<<(DebugPrinter & d, const T& output) {
  std::ostream & out = *d.outstream;
  std::streamsize savep = out.precision();
  std::ios_base::fmtflags savef =
      out.setf(std::ios_base::fixed, std::ios::floatfield);
  out << std::setprecision(static_cast<int>(d.prec_)) << std::fixed << output
      << std::setprecision(static_cast<int>(savep));
  out.setf(savef, std::ios::floatfield);
  out.flush();
  return d;
}

inline DebugPrinter & operator<<(DebugPrinter & d,
                                 std::ostream& (*pf)(std::ostream&)) {
  std::ostream & out = *d.outstream;
  out << pf;
  return d;
}

template <typename T>
inline DebugPrinter & operator,(DebugPrinter & d, const T& output) {
  return operator<<(d, output);
}

inline DebugPrinter & operator,(DebugPrinter & d,
                                std::ostream& (*pf)(std::ostream&)) {
  return operator<<(d, pf);
}

/*******************************************************************************
 * Namespace Globals
 */

// Heap allocate => no destructor call at program exit (wiped by OS).
//               => no management of std::ostream& possible
//                  (stop BLC design like shared_ptr on DebugPrinter::outstream)
static DebugPrinter& dout = *new DebugPrinter;

/*******************************************************************************
 * Macros
 */

#define dout_HERE fsc::dout(fsc::dout.detail_.filemacro_name(__FILE__),        \
                            std::to_string(__LINE__)                           \
                            + " (" + std::string(__func__) + ")",":");        //

#define dout_FUNC fsc::dout.stack(1, true);

#define dout_VAL(...) fsc::dout(#__VA_ARGS__, (__VA_ARGS__), " = ");

#define dout_TYPE(...) fsc::dout.detail_.type(                                 \
  fsc::DebugPrinter::detail::fwdtype<__VA_ARGS__>()                            \
);                                                                            //

#define dout_TYPE_OF(...) fsc::dout.detail_.type(                              \
    fsc::DebugPrinter::detail::fwdtype<decltype(__VA_ARGS__)>()                \
  , fsc::dout.detail_.valueness(__VA_ARGS__)                                   \
  , #__VA_ARGS__                                                               \
);                                                                            //

#define dout_STACK fsc::dout.stack();

#define dout_PAUSE(...)                                                        \
  if(fsc::dout.detail_.pausecheck(__VA_ARGS__))                                \
    fsc::dout.detail_.pause(#__VA_ARGS__);                                    //

#else // DEBUGPRINTER_OFF

class DebugPrinter {
  public:
  inline void operator=(std::ostream &) noexcept {}
  inline void operator=(std::ostream &&) {}
  inline void set_precision(const int) noexcept {}
  inline void set_color(...) noexcept {}
  inline void operator()(...) const {}
  inline void stack(...) const {}
};

template <typename T>
inline DebugPrinter & operator<<(DebugPrinter & d, const T&) {return d;}
inline DebugPrinter & operator<<(DebugPrinter & d,
                                 std::ostream& (*)(std::ostream&)) {return d;}
template <typename T>
inline DebugPrinter & operator,(DebugPrinter & d, const T&) {return d;}
inline DebugPrinter & operator,(DebugPrinter & d,
                                std::ostream& (*)(std::ostream&)) {return d;}

static DebugPrinter dout;

#define dout_HERE ;
#define dout_FUNC ;
#define dout_VAL(...) ;
#define dout_TYPE(...) ;
#define dout_TYPE_OF(...) ;
#define dout_STACK ;
#define dout_PAUSE(...) ;

#endif // DEBUGPRINTER_OFF

namespace detail {
  namespace dont_even_ask {

    inline void function() { (void)dout; }

  }
}

} // namespace fsc

#endif // DEBUGPRINTER_HEADER