gar::debug::CallInfo_t Struct Reference

Structure with information about a single call, parsed. More...

#include <DebugUtils.h>

Public Member Functions
	CallInfo_t (std::string const &s)
	CallInfo_t (const char *s)
	operator bool () const
	Returns whether there is some information parsed. More...
bool	operator! () const
	Returns whether no information was parsed out of the original. More...
bool	ParseString (std::string const &s)
	Returns whether the translation was complete (offset is optional!) More...
std::string const &	function () const
	Returns the function name (mangled if nothing better) More...
std::string	shortLibrary () const
	Returns only the library name (with suffix) More...

Public Attributes
std::string	original
	string from the backtrace, unparsed More...
std::string	libraryName
	parsed library name More...
std::string	functionName
	parsed function name, demangled More...
std::string	mangledFunctionName
	parsed function name, unprocessed More...
void *	address = nullptr
	function address More...
std::ptrdiff_t	offset = 0
	instruction pointer offset More...

Private Types
using	range_t = std::pair< size_t, size_t >

Private Member Functions
void	demangleFunction ()
	Runs the demangler and stores the result. More...
void	setAll (std::string const &s, range_t addressStr, range_t libraryStr, range_t functionStr, range_t offsetStr)
	Fills the information from an original string and parsed ranges. More...

Static Private Member Functions
static bool	emptyRange (range_t const &r)
	Returns whether the range is empty or invalid. More...
static std::string	extract (std::string const &s, range_t const &r)
	Translates a range into a string. More...

Detailed Description

Structure with information about a single call, parsed.

Definition at line 61 of file DebugUtils.h.

Member Typedef Documentation

using gar::debug::CallInfo_t::range_t = std::pair<size_t, size_t>

private

Definition at line 63 of file DebugUtils.h.

Constructor & Destructor Documentation

gar::debug::CallInfo_t::CallInfo_t ( std::string const &  s )

inline

Definition at line 66 of file DebugUtils.h.

{ ParseString(s); }

gar::debug::CallInfo_t::CallInfo_t ( const char *  s )

inline

Definition at line 67 of file DebugUtils.h.

{ ParseString(std::string(s)); }

Member Function Documentation

void gar::debug::CallInfo_t::demangleFunction ( )

inlineprivate

Runs the demangler and stores the result.

Definition at line 109 of file DebugUtils.h.

        { functionName = cet::demangle_symbol(mangledFunctionName); }

static bool gar::debug::CallInfo_t::emptyRange ( range_t const &  r )

inlinestaticprivate

Returns whether the range is empty or invalid.

Definition at line 102 of file DebugUtils.h.

{ return r.first >= r.second; }

static std::string gar::debug::CallInfo_t::extract ( std::string const &  s, range_t const &  r  )

inlinestaticprivate

Translates a range into a string.

Definition at line 105 of file DebugUtils.h.

        { return emptyRange(r)? "": s.substr(r.first, r.second - r.first); }

std::string const& gar::debug::CallInfo_t::function ( ) const

inline

Returns the function name (mangled if nothing better)

Definition at line 80 of file DebugUtils.h.

        { return functionName.empty()? mangledFunctionName: functionName; }

gar::debug::CallInfo_t::operator bool ( ) const

inline

Returns whether there is some information parsed.

Definition at line 70 of file DebugUtils.h.

         { return !libraryName.empty() || !mangledFunctionName.empty(); }

bool gar::debug::CallInfo_t::operator! ( ) const

inline

Returns whether no information was parsed out of the original.

Definition at line 73 of file DebugUtils.h.

         { return libraryName.empty() && mangledFunctionName.empty(); }

bool gar::debug::CallInfo_t::ParseString

(

std::string const &

s

)

Returns whether the translation was complete (offset is optional!)

Definition at line 11 of file DebugUtils.cxx.

                                                       {

  //----------------------------------------------------------------------------
#if (__linux__)
  constexpr auto boo = std::string::npos;
  range_t libraryStr  { boo, boo };
  range_t addressStr  { boo, boo };
  range_t functionStr { boo, boo };
  range_t offsetStr   { boo, boo };
  setAll(s, addressStr, libraryStr, functionStr, offsetStr);
  
  // expected format:
  // libraryName(mangledSymbol+offset) [hexAddress]
  // (+offset optional)
  
  size_t i = s.find('(');
  if (i == boo) return false;
  libraryStr.first = 0;
  while (true) {
    // at all time, if we find a '(', we start over
    // since a '(' can only be after the library name

    libraryStr  = {  0U,   i };
    addressStr  = { boo, boo };
    functionStr = { boo, boo };
    offsetStr   = { boo, boo };
    
    functionStr.first = ++i;
    
    i = s.find_first_of("(+-)", i);
    if (i == boo) return false;
    switch (s[i]) {
      case '(': continue;
      case '+': case '-':
        functionStr.second = i;
        if (s[i] == '+') ++i;
        offsetStr.first = i;
        i = s.find_first_of("()", ++i);
        if (i == boo) return false;
        switch (s[i]) {
          case '(': continue;
          case ')':
            offsetStr.second = i;
            break;
        } // switch (inner)
        break;
      case ')':
         functionStr.second = i;
         break;
    } // switch (outer)
    
    // finish with the address
    i = s.find_first_of("([", ++i);
    if (i == boo) break;
    if (s[i] == '(') continue;
    addressStr.first = ++i;
    
    i = s.find_first_of("(]", i);
    if (s[i] == '(') continue;
    addressStr.second = i;
    
    break;
  } // while (for ever)
  
  setAll(s, addressStr, libraryStr, functionStr, offsetStr);
  return true;

  //----------------------------------------------------------------------------
#elif (__APPLE__)
  // expected format:
  // N  libraryName address mangledFunction + offset
  // "+ offset" is considered optional
  original = s;
  while (true) {
    std::istringstream sstr(s);
    int n;
    char plus;
    sstr
      >> n
      >> libraryName
      >> std::hex >> address >> std::dec
      >> mangledFunctionName;
    
    // optional offset
    if (sstr.fail()) break; // an error somewhere: bail out
    sstr >> plus;
    if (sstr.fail()) offset = 0;
    else {
      if (plus != '+') break;
      sstr >> offset;
      if (sstr.fail()) break;
    }
    
    demangleFunction();
    return true;
  } // while
  address = nullptr;
  libraryName.clear();
  mangledFunctionName.clear();
  functionName.clear();
  offset = 0;
  return false;
  //----------------------------------------------------------------------------
#else
# error("I am not on Linux nor on OSX. Hard to believe.")
#endif
} // gar::debug::CallInfo_t::ParseString()

void gar::debug::CallInfo_t::setAll ( std::string const &  s, range_t  addressStr, range_t  libraryStr, range_t  functionStr, range_t  offsetStr  )

private

Fills the information from an original string and parsed ranges.

Definition at line 121 of file DebugUtils.cxx.

{
  original = s;
  
  libraryName = extract(s, libraryStr);
  
  mangledFunctionName = extract(s, functionStr);
  demangleFunction();
  
  if (!emptyRange(addressStr)) {
    std::istringstream sstr(extract(s, addressStr));
    sstr >> address;
  }
  
  if (emptyRange(offsetStr)) offset = 0;
  else {
    auto offsetRange = offsetStr;
    if (!emptyRange(offsetRange)) {
      bool neg = (s[offsetRange.first] == '-');
      std::istringstream sstr;
      if (neg || (s[offsetRange.first] == '+')) ++offsetRange.first;
      if (s.substr(offsetRange.first, 2) == "0x") {
         offsetRange.first += 2;
         sstr.setf(std::ios::hex);
      }
      sstr.str(extract(s, offsetRange));
      sstr >> offset;
      if (neg) offset = -offset;
    }
  } // if offset ... else
  
} // gar::debug::CallInfo_t::setAll()

std::string gar::debug::CallInfo_t::shortLibrary ( ) const

inline

Returns only the library name (with suffix)

Definition at line 84 of file DebugUtils.h.

        {
          size_t sep = libraryName.rfind('/');
          return (sep == std::string::npos)
            ? libraryName: libraryName.substr(sep + 1);
        //  return std::experimental::filesystem::path(libraryName).filename();
        }

Member Data Documentation

void* gar::debug::CallInfo_t::address = nullptr

function address

Definition at line 96 of file DebugUtils.h.

std::string gar::debug::CallInfo_t::functionName

parsed function name, demangled

Definition at line 94 of file DebugUtils.h.

std::string gar::debug::CallInfo_t::libraryName

parsed library name

Definition at line 93 of file DebugUtils.h.

std::string gar::debug::CallInfo_t::mangledFunctionName

parsed function name, unprocessed

Definition at line 95 of file DebugUtils.h.

std::ptrdiff_t gar::debug::CallInfo_t::offset = 0

instruction pointer offset

Definition at line 97 of file DebugUtils.h.

std::string gar::debug::CallInfo_t::original

string from the backtrace, unparsed

Definition at line 92 of file DebugUtils.h.

---

The documentation for this struct was generated from the following files:

• garsoft/CoreUtils/DebugUtils.h
• garsoft/CoreUtils/DebugUtils.cxx