std::string mettle::type_name(const T &t) {
int status;
const char *mangled = typeid(t).name();
std::unique_ptr<char, void (*)(void*)> demangled(
abi::__cxa_demangle(mangled, nullptr, nullptr, &status),
std::free
);
return status ? mangled : demangled.get();
}
std::string demangle(const char *name) {
std::string demangled(name);
int status;
char *buf = abi::__cxa_demangle(name, 0, 0, &status);
if (status == 0) {
demangled = std::string(buf);
}
free(buf);
return demangled;
}
std::string Demangler::getLeafClassname()
{
std::string demangled(this->demangle());
size_t lt_pos = demangled.find(LT);
size_t colons_pos = demangled.rfind(COLONS, lt_pos);
colons_pos = (colons_pos == std::string::npos)? 0 : colons_pos+COLONS.size();
return demangled.replace(0,colons_pos,"");
}
dynamic_string demangle(const char *pMangled)
{
int status = 0;
char *p = abi::__cxa_demangle(pMangled, 0, 0, &status);
dynamic_string demangled(p ? p : pMangled);
std::free(p);
return demangled;
}
std::string Demangler::getFullNamespace()
{
std::string demangled(this->demangle());
size_t lt_pos = demangled.find(LT);
size_t colons_pos = demangled.rfind(COLONS, lt_pos);
if(colons_pos == std::string::npos)
{
return "";
}
return demangled.replace(colons_pos, std::string::npos,"");
}
std::string
DOFMapOutput::demangle(const std::string & name)
{
#if defined(LIBMESH_HAVE_GCC_ABI_DEMANGLE)
return libMesh::demangle(name.c_str());
#else
// at least remove leading digits
std::string demangled(name);
while (demangled.length() && demangled[0] >= '0' && demangled[0] <= '9')
demangled.erase(0,1);
return demangled;
#endif
}
void serialize( std::ostream& s,
const boost::detail::sp_typeinfo& info ) const
{
const char* name = info.name();
#ifdef __GNUC__
int status = 0;
boost::shared_ptr< char > demangled(
abi::__cxa_demangle( name, 0, 0, &status ),
&std::free );
if( ! status && demangled )
serialize( s, demangled.get() );
else
#endif
serialize( s, name );
}
inline void DumpBacktrace(std::ostream& out, unsigned skip = 0)
{
static const size_t maxSize = 100;
void *array[maxSize];
int size = backtrace(array, maxSize);
if (size <= 0) return;
boost::scoped_array<char*> symbols(backtrace_symbols(array, size));
if (!symbols) return;
for (int i = skip; i < size; ++i)
{
std::string symbol(symbols[i]);
std::string::size_type pos = symbol.find('(');
std::string path(symbol, 0, pos);
std::string mangled(symbol, pos + 1, symbol.find(')') - pos - 1);
std::string offset;
pos = mangled.find('+');
if (pos != std::string::npos)
{
offset.assign(mangled, pos + 1, mangled.length() - pos);
mangled.erase(pos);
}
pos = symbol.find('[');
std::string address(symbol, pos + 1, symbol.find(']', pos) - pos - 1);
out << std::left << std::setw(3) << (i - skip + 1);
boost::scoped_array<char> demangled(abi::
__cxa_demangle(mangled.c_str(), nullptr, nullptr, nullptr));
out << path << " ";
if (demangled.get()) out << demangled.get() << " ";
else if (!mangled.empty()) out << mangled << " ";
if (!offset.empty()) out << "[+" << offset << "] ";
out << "[" << address << "]" << std::endl;
}
}
inline std::string StackFunctionName()
{
const static unsigned int index = level + 1;
void *array[level + 2];
int size = backtrace(array, level + 2);
if (size < level + 2) return "Unknown";
boost::scoped_array<char*> symbols(backtrace_symbols(array, size));
if (!symbols) return "Unknown";
char mangled[strlen(symbols[index]) + 1];
if (sscanf(symbols[index], "%*[^(](%[^+)]+", mangled) != 1) return "Unknown";
std::string function;
boost::scoped_array<char> demangled(abi::__cxa_demangle(mangled, nullptr, nullptr, nullptr));
if (demangled.get()) function.assign(demangled.get());
else function.assign(mangled);
std::string::size_type pos = function.find_first_of('(');
if (pos != std::string::npos) function.erase(pos);
return function;
}
std::string Demangler::getRootedClassname()
{
std::string demangled(this->demangle());
return COLONS + demangled;
}
std::string Demangler::getFullClassname()
{
std::string demangled(this->demangle());
return demangled;
}
void printBacktrace(std::ostream& os)
{
#ifndef _WIN32
os << "Backtrace (most recent calls first):" << std::endl << std::endl;
std::size_t maxDepth = 100;
std::size_t stackDepth;
void* stackAddrs[maxDepth];
stackDepth = ::backtrace(stackAddrs, maxDepth);
char** stackStrings;
stackStrings = ::backtrace_symbols(stackAddrs, stackDepth);
std::vector<std::string> demangled(stackDepth);
// Each printed string will have output of the form:
//
// (row) (program) (address) (function) + (offset)
//
// with variable numbers of spaces separating each field.
std::string reBacktraceString = std::string() +
"(\\d+)" + // stack number
"(\\s+)" + // spaces
"([^\\s]+)" + // program name
"(\\s+)" + // spaces
"([^\\s]+)" + // address
"(\\s+)" + // spaces
"([^\\s]+)" + // (mangled) function name
"(.*)"; // offset (the rest)
boost::regex reBacktrace(reBacktraceString);
boost::cmatch match;
for (std::size_t i = 0; i < stackDepth; ++i)
{
std::string readyForPrinting = stackStrings[i];
if (regex_utils::match(stackStrings[i], match, reBacktrace))
{
std::size_t n = match.length();
if (n >= 8)
{
std::string demangled = demangle(match[7]);
std::string joined;
for (std::size_t i = 1; i < 7; ++i)
joined += match[i];
joined += demangled;
if (n > 8)
joined += match[8];
readyForPrinting = joined;
}
}
os << readyForPrinting << std::endl;
}
if (stackStrings != nullptr)
::free(stackStrings);
#endif
}
