bool IndexerJob::visit(int build)
{
if (!mUnits.at(build).second) {
abort();
return false;
}
clang_getInclusions(mUnits.at(build).second, IndexerJob::inclusionVisitor, this);
if (isAborted())
return false;
clang_visitChildren(clang_getTranslationUnitCursor(mUnits.at(build).second),
IndexerJob::indexVisitor, this);
if (isAborted())
return false;
if (testLog(VerboseDebug)) {
VerboseVisitorUserData u = { 0, "<VerboseVisitor " + mClangLines.at(build) + ">\n", this };
clang_visitChildren(clang_getTranslationUnitCursor(mUnits.at(build).second),
IndexerJob::verboseVisitor, &u);
u.out += "</VerboseVisitor " + mClangLines.at(build) + ">";
if (getenv("RTAGS_INDEXERJOB_DUMP_TO_FILE")) {
char buf[1024];
snprintf(buf, sizeof(buf), "/tmp/%s.log", mSourceInformation.sourceFile.fileName());
FILE *f = fopen(buf, "w");
assert(f);
fwrite(u.out.constData(), 1, u.out.size(), f);
fclose(f);
} else {
logDirect(VerboseDebug, u.out);
}
}
return !isAborted();
}
void getInclusions(CXTranslationUnit tu, Inclusion** inclusionsOut,
unsigned* countOut)
{
InclusionList inclusionList = LIST_INIT(Inclusion);
clang_getInclusions(tu, inclusionListBuilder, &inclusionList);
*inclusionsOut = inclusionList.items;
*countOut = inclusionList.count;
}
void translation_unit::visitInclusions(std::function<void(file, CXSourceLocation*, unsigned)> visitor)
{
return clang_getInclusions(tu, [](CXFile included_file, CXSourceLocation* inclusion_stack, unsigned include_len, CXClientData client_data)
{
auto visitor = static_cast<std::function<void(file, CXSourceLocation*, unsigned)>*>(client_data);
return (*visitor)({ included_file }, inclusion_stack, include_len);
}, &visitor);
}
void TranslationUnit::updateIncludeFilePaths() const
{
d->dependedFilePaths.clear();
d->dependedFilePaths.insert(filePath());
clang_getInclusions(d->translationUnit, includeCallback, const_cast<TranslationUnit*>(this));
d->translationUnits.addWatchedFiles(d->dependedFilePaths);
}
void TranslationUnitUpdater::updateIncludeFilePaths()
{
m_out.dependedOnFilePaths.clear();
m_out.dependedOnFilePaths.insert(m_in.filePath);
clang_getInclusions(m_cxTranslationUnit,
includeCallback,
const_cast<TranslationUnitUpdater *>(this));
}
void CppHelperPluginView::updateInclusionExplorer()
{
assert(
"Active view supposed to be valid at this point! Am I wrong?"
&& mainWindow()->activeView()
);
// Show busy mouse pointer
QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
auto* doc = mainWindow()->activeView()->document();
auto& unit = m_plugin->getTranslationUnitByDocument(doc, false);
// Obtain diagnostic if any
{
auto diag = unit.getLastDiagnostic();
m_diagnostic_data.append(
std::make_move_iterator(begin(diag))
, std::make_move_iterator(end(diag))
);
}
details::InclusionVisitorData data =
{
this
, &m_plugin->getDocumentInfo(doc)
, decltype(details::InclusionVisitorData::m_parents){}
, {}
, nullptr
, 0
};
data.m_di->clearInclusionTree(); // Clear a previous tree in the document info
m_tool_view_interior->includesTree->clear(); // and in the tree view model
m_includes_list_model->clear(); // as well as `included by` list
data.m_parents.push(m_tool_view_interior->includesTree->invisibleRootItem());
clang_getInclusions(
unit
, [](
CXFile file
, CXSourceLocation* stack
, unsigned stack_size
, CXClientData d
)
{
auto* const user_data = static_cast<details::InclusionVisitorData* const>(d);
user_data->m_self->inclusionVisitor(user_data, file, stack, stack_size);
}
, &data
);
m_last_explored_document = doc; // Remember the document last explored
QApplication::restoreOverrideCursor(); // Restore mouse pointer to normal
kDebug(DEBUG_AREA) << "headers cache now has" << m_plugin->headersCache().size() << "items!";
}
/** filter the \a files and only keep those that are found as include files
* within the current translation unit.
* @param[in,out] files The list of files to filter.
*/
void ClangParser::determineInputFiles(QStringList &files)
{
// put the files in this translation unit in a dictionary
QSet<QString> incFound;
clang_getInclusions(p->tu, inclusionVisitor, (CXClientData) &incFound);
// create a new filtered file list
QStringList resultIncludes;
for (auto item : files) {
if (incFound.contains(item)) {
resultIncludes.append(item);
}
}
// replace the original list
files = resultIncludes;
}
bool ClangIndexer::parse()
{
StopWatch sw;
assert(!mClangUnit);
assert(!mIndex);
mIndex = clang_createIndex(0, 1);
assert(mIndex);
const unsigned int commandLineFlags = Source::FilterBlacklist|Source::IncludeDefines|Source::IncludeIncludepaths;
const unsigned int flags = CXTranslationUnit_DetailedPreprocessingRecord;
List<CXUnsavedFile> unsavedFiles(mUnsavedFiles.size() + 1);
int unsavedIndex = 0;
for (const auto &it : mUnsavedFiles) {
unsavedFiles[unsavedIndex++] = {
it.first.constData(),
it.second.constData(),
static_cast<unsigned long>(it.second.size())
};
}
debug() << "CI::parse: " << mSource.toCommandLine(commandLineFlags) << "\n";
// for (const auto it : mSource.toCommandLine(commandLineFlags)) {
// error("[%s]", it.constData());
// }
RTags::parseTranslationUnit(mSourceFile, mSource.toCommandLine(commandLineFlags), mClangUnit,
mIndex, &unsavedFiles[0], unsavedIndex, flags, &mClangLine);
warning() << "CI::parse loading unit " << mClangLine << " " << (mClangUnit != 0);
if (mClangUnit) {
clang_getInclusions(mClangUnit, ClangIndexer::inclusionVisitor, this);
mParseDuration = sw.elapsed();
return true;
}
error() << "got failure" << mClangLine;
for (Hash<uint32_t, bool>::const_iterator it = mData->visited.begin(); it != mData->visited.end(); ++it) {
mData->dependencies[it->first].insert(mSource.fileId);
addFileSymbol(it->first);
}
return false;
}
/** filter the \a files and only keep those that are found as include files
* within the current translation unit.
* @param[in,out] files The list of files to filter.
*/
void ClangParser::determineInputFilesInSameTu(QStrList &files)
{
// put the files in this translation unit in a dictionary
QDict<void> incFound(257);
clang_getInclusions(p->tu,
inclusionVisitor,
(CXClientData)&incFound
);
// create a new filtered file list
QStrList resultIncludes;
QStrListIterator it2(files);
for (it2.toFirst();it2.current();++it2)
{
if (incFound.find(it2.current()))
{
resultIncludes.append(it2.current());
}
}
// replace the original list
files=resultIncludes;
}
bool IndexerJob::parse(int build)
{
CXIndex &index = mUnits[build].first;
if (!index)
index = clang_createIndex(0, 1);
if (!index) {
abort();
return false;
}
const List<String> args = mSourceInformation.builds.at(build).args;
const List<String> &defaultArguments = Server::instance()->options().defaultArguments;
CXTranslationUnit &unit = mUnits[build].second;
assert(!unit);
mClangLines.append(String());
String &clangLine = mClangLines[build];
clangLine = Server::instance()->clangPath();
clangLine += ' ';
int idx = 0;
List<const char*> clangArgs(args.size() + defaultArguments.size(), 0);
const List<String> *lists[] = { &args, &defaultArguments };
for (int i=0; i<2; ++i) {
const int count = lists[i]->size();
for (int j=0; j<count; ++j) {
String arg = lists[i]->at(j);
if (arg.isEmpty())
continue;
if (arg == "-include" && j + 1 < count) {
const uint32_t fileId = Location::fileId(lists[i]->at(j + 1));
if (fileId) {
mData->dependencies[fileId].insert(mFileId);
}
}
clangArgs[idx++] = lists[i]->at(j).constData();
arg.replace("\"", "\\\"");
clangLine += arg;
clangLine += ' ';
}
}
clangLine += mSourceInformation.sourceFile;
unit = clang_parseTranslationUnit(index, mSourceInformation.sourceFile.constData(),
clangArgs.data(), idx, 0, 0,
CXTranslationUnit_Incomplete | CXTranslationUnit_DetailedPreprocessingRecord);
warning() << "loading unit " << clangLine << " " << (unit != 0);
if (unit) {
return !isAborted();
}
error() << "got failure" << clangLine;
const String preprocessorOnly = RTags::filterPreprocessor(mSourceInformation.sourceFile);
if (!preprocessorOnly.isEmpty()) {
CXUnsavedFile unsaved = { mSourceInformation.sourceFile.constData(), preprocessorOnly.constData(),
static_cast<unsigned long>(preprocessorOnly.size()) };
unit = clang_parseTranslationUnit(index, mSourceInformation.sourceFile.constData(),
clangArgs.data(), idx, &unsaved, 1,
CXTranslationUnit_Incomplete | CXTranslationUnit_DetailedPreprocessingRecord);
}
if (unit) {
clang_getInclusions(unit, IndexerJob::inclusionVisitor, this);
clang_disposeTranslationUnit(unit);
unit = 0;
} else {
mData->dependencies[mFileId].insert(mFileId);
}
return !isAborted();
}
void PrintInclusionStack(CXTranslationUnit TU) {
clang_getInclusions(TU, InclusionVisitor, NULL);
}
