lar::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 62 of file DebugUtils.h.

Member Typedef Documentation

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

private

Definition at line 64 of file DebugUtils.h.

Constructor & Destructor Documentation

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

inline

Definition at line 67 of file DebugUtils.h.

{ ParseString(s); }

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

inline

Definition at line 68 of file DebugUtils.h.

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

Member Function Documentation

void lar::debug::CallInfo_t::demangleFunction ( )

inlineprivate

Runs the demangler and stores the result.

Definition at line 110 of file DebugUtils.h.

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

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

inlinestaticprivate

Returns whether the range is empty or invalid.

Definition at line 103 of file DebugUtils.h.

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

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

inlinestaticprivate

Translates a range into a string.

Definition at line 106 of file DebugUtils.h.

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

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

inline

Returns the function name (mangled if nothing better).

Definition at line 81 of file DebugUtils.h.

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

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

inline

Returns whether there is some information parsed.

Definition at line 71 of file DebugUtils.h.

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

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

inline

Returns whether no information was parsed out of the original.

Definition at line 74 of file DebugUtils.h.

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

bool lar::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
} // lar::debug::CallInfo_t::ParseString()

void lar::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

} // lar::debug::CallInfo_t::setAll()

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

inline

Returns only the library name (with suffix).

Definition at line 85 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* lar::debug::CallInfo_t::address = nullptr

Function address.

Definition at line 97 of file DebugUtils.h.

std::string lar::debug::CallInfo_t::functionName

Parsed function name, demangled.

Definition at line 95 of file DebugUtils.h.

std::string lar::debug::CallInfo_t::libraryName

Parsed library name.

Definition at line 94 of file DebugUtils.h.

std::string lar::debug::CallInfo_t::mangledFunctionName

Parsed function name, unprocessed.

Definition at line 96 of file DebugUtils.h.

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

Instruction pointer offset.

Definition at line 98 of file DebugUtils.h.

std::string lar::debug::CallInfo_t::original

String from the backtrace, unparsed.

Definition at line 93 of file DebugUtils.h.

---

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

• larcorealg/larcorealg/CoreUtils/DebugUtils.h
• larcorealg/larcorealg/CoreUtils/DebugUtils.cxx