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 61 of file DebugUtils.h.

Member Typedef Documentation

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

private

Definition at line 63 of file DebugUtils.h.

Constructor & Destructor Documentation

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

inline

Definition at line 66 of file DebugUtils.h.

References ParseString().

{ ParseString(s); }

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

inline

Definition at line 67 of file DebugUtils.h.

References ParseString().

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

Member Function Documentation

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

inlineprivate

Runs the demangler and stores the result.

Definition at line 109 of file DebugUtils.h.

References setAll().

Referenced by ParseString(), and setAll().

        { 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 102 of file DebugUtils.h.

Referenced by extract(), and setAll().

{ 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 105 of file DebugUtils.h.

References emptyRange().

Referenced by setAll().

        { 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 80 of file DebugUtils.h.

References functionName, and mangledFunctionName.

Referenced by lar::debug::CallInfoPrinter::print().

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

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

inline

Returns whether there is some information parsed.

Definition at line 70 of file DebugUtils.h.

References libraryName, and mangledFunctionName.

         { 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 73 of file DebugUtils.h.

References libraryName, mangledFunctionName, ParseString(), and s.

         { 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.

References address, demangleFunction(), functionName, libraryName, mangledFunctionName, n, offset, original, s, and setAll().

Referenced by CallInfo_t(), and operator!().

                                                       {

  //----------------------------------------------------------------------------
#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.

References address, demangleFunction(), emptyRange(), extract(), if(), libraryName, mangledFunctionName, offset, original, and s.

Referenced by demangleFunction(), and ParseString().

{
  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 84 of file DebugUtils.h.

References libraryName.

Referenced by lar::debug::CallInfoPrinter::print().

        {
          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 96 of file DebugUtils.h.

Referenced by ParseString(), lar::debug::CallInfoPrinter::print(), and setAll().

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

Parsed function name, demangled.

Definition at line 94 of file DebugUtils.h.

Referenced by function(), and ParseString().

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

Parsed library name.

Definition at line 93 of file DebugUtils.h.

Referenced by operator bool(), operator!(), ParseString(), lar::debug::CallInfoPrinter::print(), setAll(), and shortLibrary().

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

Parsed function name, unprocessed.

Definition at line 95 of file DebugUtils.h.

Referenced by function(), operator bool(), operator!(), ParseString(), lar::debug::CallInfoPrinter::print(), and setAll().

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

Instruction pointer offset.

Definition at line 97 of file DebugUtils.h.

Referenced by ParseString(), lar::debug::CallInfoPrinter::print(), and setAll().

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

String from the backtrace, unparsed.

Definition at line 92 of file DebugUtils.h.

Referenced by ParseString(), lar::debug::CallInfoPrinter::print(), and setAll().

---

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

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