void DumpThread::run()
{
const auto key = mConnection->disconnected().connect([this](const std::shared_ptr<Connection> &) { abort(); });
CXIndex index = clang_createIndex(0, 0);
CXTranslationUnit translationUnit = 0;
String clangLine;
RTags::parseTranslationUnit(mSource.sourceFile(), mSource.toCommandLine(Source::Default), translationUnit,
index, 0, 0, CXTranslationUnit_DetailedPreprocessingRecord, &clangLine);
if (!(mQueryFlags & QueryMessage::DumpCheckIncludes))
writeToConnetion(String::format<128>("Indexed: %s => %s", clangLine.constData(), translationUnit ? "success" : "failure"));
if (translationUnit) {
clang_visitChildren(clang_getTranslationUnitCursor(translationUnit), DumpThread::visitor, this);
clang_disposeTranslationUnit(translationUnit);
}
clang_disposeIndex(index);
mConnection->disconnected().disconnect(key);
std::weak_ptr<Connection> conn = mConnection;
if (mQueryFlags & QueryMessage::DumpCheckIncludes) {
checkIncludes();
}
EventLoop::mainEventLoop()->callLater([conn]() {
if (auto c = conn.lock())
c->finish();
});
}
CXChildVisitResult DumpThread::visit(const CXCursor &cursor)
{
if (isAborted())
return CXChildVisit_Break;
const Location location = createLocation(cursor);
if (!location.isNull()) {
if (mQueryFlags & QueryMessage::DumpCheckIncludes) {
checkIncludes(location, cursor);
return CXChildVisit_Recurse;
} else {
Flags<Location::ToStringFlag> locationFlags;
if (mQueryFlags & QueryMessage::NoColor)
locationFlags |= Location::NoColor;
CXSourceRange range = clang_getCursorExtent(cursor);
CXSourceLocation rangeEnd = clang_getRangeEnd(range);
unsigned int endLine, endColumn;
clang_getPresumedLocation(rangeEnd, 0, &endLine, &endColumn);
if (!(mQueryFlags & QueryMessage::DumpIncludeHeaders) && location.fileId() != mSource.fileId) {
return CXChildVisit_Continue;
}
String message;
message.reserve(256);
if (!(mQueryFlags & QueryMessage::NoContext)) {
message = location.context(locationFlags);
}
if (endLine == location.line()) {
message += String::format<32>(" // %d-%d, %d: ", location.column(), endColumn, mIndentLevel);
} else {
message += String::format<32>(" // %d-%d:%d, %d: ", location.column(), endLine, endColumn, mIndentLevel);
}
message += RTags::cursorToString(cursor, RTags::AllCursorToStringFlags);
message.append(" " + RTags::typeName(cursor));;
if (clang_getCursorKind(cursor) == CXCursor_VarDecl) {
const std::shared_ptr<RTags::Auto> autoResolved = RTags::resolveAuto(cursor);
if (autoResolved && !clang_equalCursors(autoResolved->cursor, nullCursor)) {
message += "auto resolves to " + RTags::cursorToString(autoResolved->cursor, RTags::AllCursorToStringFlags);
}
}
CXCursor ref = clang_getCursorReferenced(cursor);
if (clang_equalCursors(ref, cursor)) {
message.append("refs self");
} else if (!clang_equalCursors(ref, nullCursor)) {
message.append("refs ");
message.append(RTags::cursorToString(ref, RTags::AllCursorToStringFlags));
}
CXCursor canonical = clang_getCanonicalCursor(cursor);
if (!clang_equalCursors(canonical, cursor) && !clang_equalCursors(canonical, nullCursor)) {
message.append("canonical ");
message.append(RTags::cursorToString(canonical, RTags::AllCursorToStringFlags));
}
CXCursor specialized = clang_getSpecializedCursorTemplate(cursor);
if (!clang_equalCursors(specialized, cursor) && !clang_equalCursors(specialized, nullCursor)) {
message.append("specialized ");
message.append(RTags::cursorToString(specialized, RTags::AllCursorToStringFlags));
}
writeToConnetion(message);
}
}
++mIndentLevel;
clang_visitChildren(cursor, DumpThread::visitor, this);
if (isAborted())
return CXChildVisit_Break;
--mIndentLevel;
return CXChildVisit_Continue;
}
Indicator * CUS::calculate ()
{
Config config;
QStringList varList;
QDict<PlotLine> lines;
lines.setAutoDelete(TRUE);
checkIncludes();
Indicator *output = new Indicator;
output->setDateFlag(dateFlag);
output->setLogScale(logScale);
int loop;
for (loop = 0; loop < (int) formulaList.count(); loop++)
{
// check if whole line is a comment
QString s = formulaList[loop].left(2);
if ( ! s.compare("//"))
continue;
if (formulaList[loop].contains(":="))
{
QStringList l = QStringList::split(":=", formulaList[loop], FALSE);
if (l.count() != 2)
{
qDebug("CUS::calculate: line %i parm missing", loop);
return output;
}
QString var = l[0].stripWhiteSpace();
if (varList.findIndex(var) != -1)
{
qDebug("CUS::calculate: line %i duplicate variable: %s", loop, var.latin1());
return output;
}
varList.append(var);
QStringList l2 = QStringList::split("(", l[1], FALSE);
if (l2.count() != 2)
{
qDebug("CUS::calculate: line %i bad indicator format", loop);
return output;
}
QString plugin = l2[0].stripWhiteSpace();
QString parms = l2[1];
parms.truncate(parms.find(")", 0, TRUE));
parms = parms.stripWhiteSpace();
while(parms.contains(" "))
parms = parms.remove(parms.find(" ", 0, TRUE), 1);
IndicatorPlugin *plug = config.getIndicatorPlugin(plugin);
if (! plug)
{
qDebug("CUS::calculate: %s plugin not loaded", plugin.latin1());
config.closePlugin(plugin);
return output;
}
plug->setIndicatorInput(data);
l = QStringList::split(",", parms, FALSE);
int loop2;
QPtrList<PlotLine> inList;
inList.setAutoDelete(FALSE);
for (loop2 = 0; loop2 < (int) l.count(); loop2++)
{
if (varList.findIndex(l[loop2]) != -1)
inList.append(lines.find(l[loop2]));
else
{
int itype = inputTypeList.findIndex(l[loop2]);
if (itype != -1)
{
PlotLine *in = data->getInput((BarData::InputType) itype);
if (! in)
{
qDebug("CUS::calculate:line%i parm%i: input not found", loop, loop2);
return output;
}
lines.replace(l[loop2], in);
inList.append(in);
}
}
}
PlotLine *out = plug->calculateCustom(parms, inList);
if (! out)
{
qDebug("CUS::calculate: line %i: no PlotLine returned: %s", loop, parms.latin1());
config.closePlugin(plugin);
return output;
}
lines.replace(var, out);
}
createPlot(formulaList[loop], lines, output);
}
return output;
}
