format-obj.cpp

Go to the documentation of this file.

/*
  FormatObj  -  simple means to display an object

  Copyright (C)         Lumiera.org
    2016,               Hermann Vosseler <Ichthyostega@web.de>

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of
  the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

* *****************************************************/

#include "lib/error.hpp"
#include "lib/format-obj.hpp"
#include "lib/ios-savepoint.hpp"
//#include "lib/format-string.hpp"
#include "lib/unique-malloc-owner.hpp"
#include "lib/symbol.hpp"
#include "lib/util.hpp"

#ifdef __GNUG__
#include <cxxabi.h>
#endif

#include <limits>
#include <iomanip>
#include <sstream>
#include <string>
#include <regex>

//using util::_Fmt;
using util::removePrefix;
using util::removeSuffix;
using util::isnil;
using std::string;

using std::regex;
using std::regex_replace;


namespace { // hard-wired configuration for debugging output....
  
  // precision for rendering of double values
  const auto DIAGNOSTICS_DOUBLE_PRECISION = 8;
  const auto DIAGNOSTICS_FLOAT_PRECISION  = 5;
  
  const size_t DIAGNOSTICS_ADDRESS_SUFFIX_LEN = 4;
  
  
  template<typename F>
  constexpr size_t PRECISION_DECIMAL = std::numeric_limits<F>::digits10;
  
  template<typename F>
  constexpr size_t PRECISION_COMPLETE = std::numeric_limits<F>::max_digits10;
}



namespace lib  {
namespace meta {
  
  // pre-allocated failure indicators, which can be returned failsafe.
  
  extern const string BOTTOM_INDICATOR  = "⟂";
  extern const string FAILURE_INDICATOR = "↯";
  extern const string VOID_INDICATOR    = "void";
  extern const string FUNCTION_INDICATOR= "Function";
  
  extern const string BOOL_FALSE_STR = "false";
  extern const string BOOL_TRUE_STR = "true";
  
  
  
#ifdef __GNUG__

  string
  demangleCxx (Literal rawName)
  {
    int error = -4;
    UniqueMallocOwner<char> demangled (abi::__cxa_demangle (rawName,
                                                            NULL,
                                                            NULL,
                                                            &error));
    return 0==error? demangled.get()
                   : string(rawName);
  }
  
  
#else
#warning "Lumiera was _not_ built with a GCC compatible compiler."
#warning "There are good chances this works without problems, but up to now, \
the Lumiera developers lacked the resources to investigate that option; \
apologies for that."
  
  string
  demangleCxx (Literal rawName)
  {
    return string (rawName);
  }
#endif
  
  
  
  
  
  string
  humanReadableTypeID (Literal rawType)
  {
    string typeName = demangleCxx (rawType);
    
    #define TYP_EXP "[\\w<>\\(\\):,\\s]+"
    
    static regex commonPrefixes {"std::"
                                "|(\\w+::)+\\(anonymous namespace\\)::"
                                "|lib::meta::"
                                "|lib::time::"
                                "|lib::test::"
                                "|lib::diff::"
                                "|lib::"
                                "|util::"
                                "|steam::(asset::|mobject::(session::)?|play::)?"
                                "|stage::model"
                                "|stage::ctrl"
                                "|lumiera::"
                                , regex::ECMAScript | regex::optimize};
    
    static regex stdString {"(__cxx11::)?basic_string<char, char_traits<char>, allocator<char>\\s*>(\\s+\\B)?"
                                , regex::ECMAScript | regex::optimize};
    
    static regex stdAllocator {"(\\w+<(" TYP_EXP ")), allocator<\\2>\\s*"
                                , regex::ECMAScript | regex::optimize};
    
    static regex mapAllocator {"(map<(" TYP_EXP "), (" TYP_EXP ")),.+allocator<pair<\\2 const, \\3>\\s*>\\s*"
                                , regex::ECMAScript | regex::optimize};
    
    static regex uniquePtr {"unique_ptr<(\\w+), default_delete<\\1>\\s*"
                                , regex::ECMAScript | regex::optimize};
    
    static regex lumieraP {"P<(\\w+), shared_ptr<\\1>\\s*"
                                , regex::ECMAScript | regex::optimize};
    
    
    auto pos = typeName.begin();
    auto end = typeName.end();
    
    end = regex_replace(pos, pos, end, commonPrefixes, "");
    end = regex_replace(pos, pos, end, stdString, "string");
    end = regex_replace(pos, pos, end, stdAllocator, "$1");
    end = regex_replace(pos, pos, end, mapAllocator, "$1");
    end = regex_replace(pos, pos, end, uniquePtr, "unique_ptr<$1");
    end = regex_replace(pos, pos, end, lumieraP, "P<$1");

    typeName.resize(end - typeName.begin());
    return typeName;
  }
  
  
  
  string
  primaryTypeComponent (Literal rawType)
  {
    string typeStr = demangleCxx (rawType);
    
    removeSuffix (typeStr, " const");
    removeSuffix (typeStr, " const *");
    removeSuffix (typeStr, "*");
    removeSuffix (typeStr, "&");
    
    if (isnil (typeStr)) return VOID_INDICATOR;
    if (')' == typeStr.back()) return FUNCTION_INDICATOR;
    
    auto end = typeStr.end();
    auto beg = typeStr.begin();
    int level=0;
    while (--end != beg)
      {
        if ('>' == *end)
          ++level;
        else if ('<' == *end and level>0)
          --level;
        else
          if (level==0)
          {
            ++end;
            break;
          }
      }
    if (end == beg) return VOID_INDICATOR;
    
    auto pos = typeStr.rfind("::", end-beg);
    typeStr = (pos==string::npos? typeStr.substr(0, end-beg)
                                : typeStr.substr(pos+2, (end-beg)-pos-2));
    return typeStr;
  }
  
  
  string
  sanitisedFullTypeName (lib::Literal rawName)
  {
    return util::sanitise (humanReadableTypeID (rawName));
  }
  
  
  string
  sanitisedSymbol (string const& text)
  {
    static regex identifierChars {"[A-Za-z]\\w*", regex::ECMAScript | regex::optimize};
    
    return regex_replace (text, identifierChars, "$&", std::regex_constants::format_no_copy);
  }                                                      // don't copy what does not match
  
  
  
}}// namespace lib::meta





/* === formatting and pretty printing support utils === */

namespace util {
  
  using std::hex;
  using std::setw;
  using std::right;
  using std::setfill;
  using std::uppercase;
  using std::noshowbase;
  using std::ostringstream;
  using std::ostream;

  template<typename F>
  string
  showFloatingPoint (F val, size_t precision)  noexcept
    try {
      ostringstream buffer;
      buffer.precision (precision);
      buffer << val;
      return buffer.str();
    }
    catch(...)
    { return FAILURE_INDICATOR; }
  
  string showDouble (double val)   noexcept { return showFloatingPoint (val, DIAGNOSTICS_DOUBLE_PRECISION); }
  string showFloat  (float val)    noexcept { return showFloatingPoint (val, DIAGNOSTICS_FLOAT_PRECISION); }
  
  string showDecimal (double val)  noexcept { return showFloatingPoint (val, PRECISION_DECIMAL<double>); }
  string showDecimal (float val)   noexcept { return showFloatingPoint (val, PRECISION_DECIMAL<float>); }
  string showDecimal (f128 val)    noexcept { return showFloatingPoint (val, PRECISION_DECIMAL<f128>); }
  
  string showComplete (double val) noexcept { return showFloatingPoint (val, PRECISION_COMPLETE<double>); }
  string showComplete (float val)  noexcept { return showFloatingPoint (val, PRECISION_COMPLETE<float>); }
  string showComplete (f128 val)   noexcept { return showFloatingPoint (val, PRECISION_COMPLETE<f128>); }
  
  
  string
  showSize (size_t val)   noexcept
    try {
      ostringstream buffer;
      buffer << val;
      return buffer.str();
    }
    catch(...)
    { return FAILURE_INDICATOR; }
  
  
  ostream&
  showAddr (ostream& stream, void const* addr)
  {
    IosSavepoint save{stream};
    size_t suffix_modulus = size_t(1) << DIAGNOSTICS_ADDRESS_SUFFIX_LEN * 8;
    return stream << "╲"
                  << hex
                  << noshowbase
                  << setw (DIAGNOSTICS_ADDRESS_SUFFIX_LEN * 2)  // need 2 hex digits per byte
                  << setfill('_')
                  << right
                  << size_t(addr) % suffix_modulus;
  }
  
  
  string
  showAddr (void const* addr)  noexcept
    try {
      ostringstream buffer;
      showAddr (buffer, addr);
      return buffer.str();
    }
    catch(...)
    { return FAILURE_INDICATOR; }
  
  
  string
  showHash (size_t hash, uint showBytes)  noexcept
    try {
      showBytes = util::limited (1u, showBytes, 8u);
      size_t suffix_modulus = size_t(1) << showBytes * 8;
      ostringstream buffer;
      buffer << hex
             << uppercase
             << noshowbase
             << setw (showBytes * 2)  // need 2 hex digits per byte
             << setfill('0')
             << right
             << (showBytes==8? hash : hash % suffix_modulus);
      return buffer.str();
    }
    catch(...)
    { return FAILURE_INDICATOR; }
  
  
  
} // namespace util