static std::vector<std::string> innerTypesOf(const std::string &t)
{
std::vector<std::string> rc;
std::string::size_type pos = t.find('<');
if (pos == std::string::npos)
return rc;
// exclude special values like "<Value unavailable error>"
if (pos == 0)
return rc;
// exclude untyped member in the form of class::<untyped>
if (pos >= 2 && t.at(pos - 1) == ':' && t.at(pos - 2) == ':')
return rc;
rc.reserve(5);
const std::string::size_type size = t.size();
// Record all elements of level 1 to work correctly for
// 'std::map<std::basic_string< .. > >'
unsigned level = 0;
std::string::size_type start = 0;
for ( ; pos < size ; pos++) {
const char c = t.at(pos);
switch (c) {
case '<':
if (++level == 1)
start = pos + 1;
break;
case '>':
if (--level == 0) { // last element
std::string innerType = t.substr(start, pos - start);
trimFront(innerType);
trimBack(innerType);
rc.push_back(innerType);
return rc;
}
break;
case ',':
if (level == 1) { // std::map<a, b>: start anew at ','.
std::string innerType = t.substr(start, pos - start);
trimFront(innerType);
trimBack(innerType);
rc.push_back(innerType);
start = pos + 1;
}
break;
}
}
return rc;
}
PyType PyType::lookupType(const std::string &typeNameIn, ULONG64 module)
{
if (debuggingTypeEnabled())
DebugPrint() << "lookup type '" << typeNameIn << "'";
std::string typeName = typeNameIn;
trimBack(typeName);
trimFront(typeName);
if (isPointerType(typeName) || isArrayType(typeName))
return PyType(0, 0, typeName);
if (typeName.find("enum ") == 0)
typeName.erase(0, 5);
if (endsWith(typeName, " const"))
typeName.erase(typeName.length() - 6);
if (typeName == "__int64" || typeName == "unsigned __int64")
typeName.erase(typeName.find("__"), 2);
const static std::regex typeNameRE("^[a-zA-Z_][a-zA-Z0-9_]*!?[a-zA-Z0-9_<>:, \\*\\&\\[\\]]*$");
if (!std::regex_match(typeName, typeNameRE))
return PyType();
CIDebugSymbols *symbols = ExtensionCommandContext::instance()->symbols();
ULONG typeId;
HRESULT result = S_FALSE;
if (module != 0 && !isIntegralType(typeName) && !isFloatType(typeName))
result = symbols->GetTypeId(module, typeName.c_str(), &typeId);
if (FAILED(result) || result == S_FALSE)
result = symbols->GetSymbolTypeId(typeName.c_str(), &typeId, &module);
if (FAILED(result))
return createUnresolvedType(typeName);
return PyType(module, typeId, typeName);
}
void simplify(std::string &s)
{
trimFront(s);
trimBack(s);
if (s.empty())
return;
// 1) All blanks
const std::string::size_type size1 = s.size();
std::string::size_type pos = 0;
for ( ; pos < size1; pos++)
if (std::isspace(s.at(pos)))
s[pos] = ' ';
// 2) Simplify
for (pos = 0; pos < s.size(); ) {
std::string::size_type blankpos = s.find(' ', pos);
if (blankpos == std::string::npos)
break;
std::string::size_type tokenpos = blankpos + 1;
while (tokenpos < s.size() && s.at(tokenpos) == ' ')
tokenpos++;
if (tokenpos - blankpos > 1)
s.erase(blankpos, tokenpos - blankpos - 1);
pos = blankpos + 1;
}
}
static std::string stripPointerType(const std::string &typeNameIn)
{
if (typeNameIn.empty())
return typeNameIn;
std::string typeName = typeNameIn;
if (typeName.back() == '*') {
typeName.pop_back();
} else {
const auto arrayPosition = typeName.find_first_of('[');
if (arrayPosition != std::string::npos
&& arrayPosition >= 3 && isArrayPointerAtPosition(typeName, arrayPosition - 3)) {
typeName.erase(arrayPosition - 3, 3);
}
}
trimBack(typeName);
return typeName;
}
// Simplify: replace tabs, find all occurrences
// of 2 blanks, check further up for blanks and remove that bit.
QByteArray simplify(const QByteArray &inIn)
{
if (inIn.isEmpty())
return inIn;
QByteArray in = trimFront(trimBack(inIn));
in.replace('\t', ' ');
in.replace('\n', ' ');
in.replace('\r', ' ');
const QByteArray twoBlanks = " ";
while (true) {
const int pos = in.indexOf(twoBlanks);
if (pos != -1) {
const int size = in.size();
int endPos = pos + twoBlanks.size();
for ( ; endPos < size && in.at(endPos) == ' '; endPos++) ;
in.remove(pos + 1, endPos - pos - 1);
} else {
break;
}
}
return in;
}
