/*
testGetInstance of the OS provider.
*/
void OSTestClient::testGetInstance (CIMClient &client,
Boolean verboseTest)
{
CIMObjectPath getTestRef; // will need an instance for Get
try
{
Boolean deepInheritance = true;
Boolean localOnly = true;
testLog("OS Provider Test GetInstance");
// first do an EnumerateInstanceNames - select one to play with
// doesn't hurt to keep testing enumerate :-)
Array<CIMObjectPath> cimReferences =
client.enumerateInstanceNames(NAMESPACE, CLASSNAME);
Uint32 numberInstances = cimReferences.size();
if (verboseTest)
cout << numberInstances << " instances of PG_OperatingSystem" <<endl;
for (Uint32 i = 0; i < cimReferences.size(); i++)
{
CIMName className = cimReferences[i].getClassName();
if (!className.equal (CLASSNAME))
{
errorExit("EnumInstanceNames failed - wrong class");
}
// add in some content checks on the keys returned
_validateKeys(cimReferences[i], verboseTest);
// let's just take the first instance found
getTestRef = cimReferences[i];
} // end for looping through instances
if (verboseTest)
cout<<"EnumerateInstanceNames for Get Instance completed"<<endl;
// now call GetInstance with the appropriate references
CIMInstance getTestInstance = client.getInstance(NAMESPACE,
getTestRef);
// now validate the properties returned
_validateProperties(getTestInstance, verboseTest);
testLog("OS Provider Test Get Instance passed ");
} // end try
catch(Exception& e)
{
errorExit(e.getMessage());
}
}
int main()
{
// Create a sink for output
std::shared_ptr<smlog::Sink> sink =
std::make_shared<SinkToStdOut>();
// Create the log
smlog::Logger log;
log.AddSink(sink);
// Add some prefix tokens for each log message
std::unique_ptr<smlog::FBCustomStr> fb0(
new smlog::FBCustomStr("TRACE: LIBNAME: " ));
std::unique_ptr<smlog::FBCustomStr> fb1(
new smlog::FBCustomStr("DEBUG: LIBNAME: " ));
std::unique_ptr<smlog::FBCustomStr> fb2(
new smlog::FBCustomStr("INFO: LIBNAME: " ));
std::unique_ptr<smlog::FBCustomStr> fb3(
new smlog::FBCustomStr("WARN: LIBNAME: " ));
std::unique_ptr<smlog::FBCustomStr> fb4(
new smlog::FBCustomStr("ERROR: LIBNAME: " ));
std::unique_ptr<smlog::FBCustomStr> fb5(
new smlog::FBCustomStr("FATAL: LIBNAME: " ));
log.AddFormatBlock(std::move(fb0),smlog::Logger::Level::TRACE);
log.AddFormatBlock(std::move(fb1),smlog::Logger::Level::DEBUG);
log.AddFormatBlock(std::move(fb2),smlog::Logger::Level::INFO);
log.AddFormatBlock(std::move(fb3),smlog::Logger::Level::WARN);
log.AddFormatBlock(std::move(fb4),smlog::Logger::Level::ERROR);
log.AddFormatBlock(std::move(fb5),smlog::Logger::Level::FATAL);
testLog(log);
// Test setting / unsetting log levels. All levels
// are initially enabled by default
log.UnsetLevel(smlog::Logger::Level::TRACE);
log.UnsetLevel(smlog::Logger::Level::DEBUG);
log.UnsetLevel(smlog::Logger::Level::WARN);
std::cout << std::endl;
testLog(log);
log.SetLevel(smlog::Logger::Level::DEBUG);
std::cout << std::endl;
testLog(log);
return 0;
}
/*
testEnumerateInstances of the NIS provider.
*/
void NISTestClient::testEnumerateInstances(
CIMClient &client,
Boolean verboseTest)
{
try
{
Boolean deepInheritance = true;
Boolean localOnly = true;
Boolean includeQualifiers = false;
Boolean includeClassOrigin = false;
Uint32 numberInstances;
testLog("NIS Provider Test EnumerateInstances");
Array<CIMInstance> cimNInstances = client.enumerateInstances(
NAMESPACE,
CLASS_NAME,
deepInheritance,
localOnly,
includeQualifiers,
includeClassOrigin);
numberInstances = cimNInstances.size();
if (verboseTest)
cout << numberInstances << " instances of PG_NISServerService" <<
endl;
for (Uint32 i = 0; i < cimNInstances.size(); i++)
{
CIMObjectPath instanceRef = cimNInstances[i].getPath ();
if (verboseTest)
cout << "Instance ClassName is " <<
instanceRef.getClassName().getString() << endl;
if(!instanceRef.getClassName().equal(CLASS_NAME))
{
errorExit("EnumInstances failed");
}
// now validate the properties
_validateProperties(cimNInstances[i], verboseTest);
} // end for looping through instances
testLog("NIS Provider Test EnumInstances Passed");
}
catch(Exception& e)
{
errorExit(e.getMessage());
}
}
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();
}
/*
testEnumerateInstanceNames of the NIS provider.
*/
void NISTestClient::testEnumerateInstanceNames(
CIMClient &client,
Boolean verboseTest)
{
try
{
Uint32 numberInstances;
testLog("NIS Provider Test Start EnumerateInstanceNames");
Array<CIMObjectPath> cimReferences =
client.enumerateInstanceNames(NAMESPACE, CLASS_NAME);
numberInstances = cimReferences.size();
if (verboseTest)
cout << numberInstances << " instances of " <<
CLASS_NAME.getString() <<endl;
for (Uint32 i = 0; i < cimReferences.size(); i++)
{
CIMName className = cimReferences[i].getClassName();
if (!className.equal(CLASS_NAME))
{
errorExit("EnumInstanceNames failed - wrong class");
}
_validateKeys(cimReferences[i], verboseTest);
} // end for looping through instances
testLog("NIS Provider Test EnumInstanceNames Passed");
}
catch(Exception& e)
{
errorExit(e.getMessage());
}
}
int main( int argc, char ** argv )
{
if ( argc == 2 )
dataPath = argv[1];
std::cout << "System uses " << ( IS_BIG_ENDIAN ? " B I G " : "little" );
std::cout << " endian byte order." << std::endl;
// Test-load each binary config file.
testGps( dataPath );
testLog( dataPath );
testSys( dataPath );
return 0;
}
static inline void eatAutoTools(List<ByteArray> &args)
{
List<ByteArray> copy = args;
for (int i=0; i<args.size(); ++i) {
if (args.at(i).contains("gcc") || args.at(i).contains("g++") || args.at(i) == "cd" || args.at(i) == "c++") {
if (i) {
args.erase(args.begin(), args.begin() + i);
if (testLog(Debug)) {
debug() << "ate something " << copy;
debug() << "now we have " << args;
}
}
break;
}
}
}
void Project::onJobFinished(const shared_ptr<IndexerJob> &job)
{
PendingJob pending;
bool startPending = false;
{
MutexLocker lock(&mMutex);
const uint32_t fileId = job->fileId();
if (job->isAborted()) {
mVisitedFiles -= job->visitedFiles();
--mJobCounter;
pending = mPendingJobs.take(fileId, &startPending);
if (mJobs.value(fileId) == job)
mJobs.remove(fileId);
} else {
assert(mJobs.value(fileId) == job);
mJobs.remove(fileId);
shared_ptr<IndexData> data = job->data();
mPendingData[fileId] = data;
const int idx = mJobCounter - mJobs.size();
mSources[fileId].parsed = job->parseTime();
if (testLog(RTags::CompilationErrorXml))
log(RTags::CompilationErrorXml, "<?xml version=\"1.0\" encoding=\"utf-8\"?><progress index=\"%d\" total=\"%d\"></progress>",
idx, mJobCounter);
error("[%3d%%] %d/%d %s %s.",
static_cast<int>(round((double(idx) / double(mJobCounter)) * 100.0)), idx, mJobCounter,
String::formatTime(time(0), String::Time).constData(),
data->message.constData());
if (mJobs.isEmpty()) {
mSyncTimer.start(shared_from_this(), job->type() == IndexerJob::Dirty ? 0 : SyncTimeout,
SingleShot, Sync);
}
}
}
if (startPending)
index(pending.source, pending.type);
}
int main(int argc, char * argv[])
{
// getopt_main(argc, argv);
// test_ChangeTHEX2CPTR();
// test_string_convert();
// testRandMN();
// testSetBitVecC();
// testGetString();
testLog();
// testBinSearch();
// testRandNumber();
// testShift();
// testSetArray();
// testSetList();
// testSetBST();
// testSetBitVec();
// WordSort1();
// testWordSort2();
// testTime();
return 0;
}
void CompletionJob::processDiagnostics(CXCodeCompleteResults* results)
{
if (!testLog(CompilationError))
return;
const unsigned int numDiags = clang_codeCompleteGetNumDiagnostics(results);
for (unsigned int curDiag = 0; curDiag < numDiags; ++curDiag) {
CXDiagnostic diagnostic = clang_codeCompleteGetDiagnostic(results, curDiag);
const unsigned diagnosticOptions = (CXDiagnostic_DisplaySourceLocation|
CXDiagnostic_DisplayColumn|
CXDiagnostic_DisplaySourceRanges|
CXDiagnostic_DisplayOption|
CXDiagnostic_DisplayCategoryId|
CXDiagnostic_DisplayCategoryName);
const ByteArray text = RTags::eatString(clang_formatDiagnostic(diagnostic, diagnosticOptions));
log(CompilationError, "%s", text.constData());
clang_disposeDiagnostic(diagnostic);
}
log(CompilationError, "$");
}
static void log(int level, const char *format, va_list v)
{
if (!testLog(level))
return;
va_list v2;
va_copy(v2, v);
enum { Size = 16384 };
char buf[Size];
char *msg = buf;
int n = vsnprintf(msg, Size, format, v);
if (n == -1) {
va_end(v2);
return;
}
if (n >= Size) {
msg = new char[n + 2];
n = vsnprintf(msg, n + 1, format, v2);
}
std::lock_guard<std::mutex> lock(sOutputsMutex);
if (sOutputs.isEmpty()) {
printf("%s\n", msg);
} else {
for (Set<LogOutput*>::const_iterator it = sOutputs.begin(); it != sOutputs.end(); ++it) {
LogOutput *output = *it;
if (output->testLog(level)) {
output->log(msg, n);
}
}
}
if (msg != buf)
delete []msg;
va_end(v2);
}
static void log(LogLevel level, const char *format, va_list v)
{
if (!testLog(level))
return;
va_list v2;
va_copy(v2, v);
enum { Size = 16384 };
StackBuffer<Size> buf(Size);
int n = vsnprintf(buf, Size, format, v);
if (n == -1) {
va_end(v2);
return;
}
if (n >= Size) {
buf.resize(n + 2);
n = vsnprintf(buf, n + 1, format, v2);
}
logDirect(level, buf, n);
va_end(v2);
}
bool ClangIndexer::visit()
{
if (!mClangUnit || !mSource.fileId) {
return false;
}
StopWatch watch;
clang_visitChildren(clang_getTranslationUnitCursor(mClangUnit),
ClangIndexer::indexVisitor, this);
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);
}
mVisitDuration = watch.elapsed();
if (testLog(VerboseDebug)) {
VerboseVisitorUserData u = { 0, "<VerboseVisitor " + mClangLine + ">\n", this };
clang_visitChildren(clang_getTranslationUnitCursor(mClangUnit),
ClangIndexer::verboseVisitor, &u);
u.out += "</VerboseVisitor " + mClangLine + ">";
if (getenv("RTAGS_INDEXERJOB_DUMP_TO_FILE")) {
char buf[1024];
snprintf(buf, sizeof(buf), "/tmp/%s.log", Location::path(mSource.fileId).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 true;
}
void CompletionThread::process(Request *request)
{
// if (!request->unsaved.isEmpty()) {
// int line = request->location.line();
// int pos = 0;
// while (line > 1) {
// int p = request->unsaved.indexOf('\n', pos);
// if (p == -1) {
// pos = -1;
// break;
// }
// pos = p + 1;
// --line;
// }
// if (pos != -1) {
// int end = request->unsaved.indexOf('\n', pos);
// if (end == -1)
// end = request->unsaved.size();
// error("Completing at %s:%d:%d line: [%s]\n",
// request->location.path().constData(),
// request->location.line(),
// request->location.column(),
// request->unsaved.mid(pos, end - pos).constData());
// }
// }
StopWatch sw;
int parseTime = 0;
int reparseTime = 0;
int completeTime = 0;
int processTime = 0;
SourceFile *&cache = mCacheMap[request->source.fileId];
if (cache && cache->source != request->source) {
delete cache;
cache = 0;
}
if (!cache) {
cache = new SourceFile;
mCacheList.append(cache);
while (mCacheMap.size() > mCacheSize) {
SourceFile *c = mCacheList.removeFirst();
mCacheMap.remove(c->source.fileId);
delete c;
}
} else {
mCacheList.moveToEnd(cache);
}
const bool sendDebug = testLog(LogLevel::Debug);
if (cache->translationUnit && cache->source != request->source) {
clang_disposeTranslationUnit(cache->translationUnit);
cache->translationUnit = 0;
cache->source = request->source;
} else if (!cache->translationUnit) {
cache->source = request->source;
}
const Path sourceFile = request->source.sourceFile();
CXUnsavedFile unsaved = {
sourceFile.constData(),
request->unsaved.constData(),
static_cast<unsigned long>(request->unsaved.size())
};
size_t hash = 0;
uint64_t lastModified = 0;
if (request->unsaved.size()) {
std::hash<String> h;
hash = h(request->unsaved);
} else {
lastModified = sourceFile.lastModifiedMs();
}
const auto &options = Server::instance()->options();
if (!cache->translationUnit) {
cache->completionsMap.clear();
cache->completionsList.deleteAll();
sw.restart();
Flags<CXTranslationUnit_Flags> flags = static_cast<CXTranslationUnit_Flags>(clang_defaultEditingTranslationUnitOptions());
flags |= CXTranslationUnit_PrecompiledPreamble;
flags |= CXTranslationUnit_CacheCompletionResults;
flags |= CXTranslationUnit_SkipFunctionBodies;
for (const auto &inc : options.includePaths) {
request->source.includePaths << inc;
}
request->source.defines << options.defines;
String clangLine;
RTags::parseTranslationUnit(sourceFile, request->source.toCommandLine(Source::Default|Source::ExcludeDefaultArguments),
cache->translationUnit, mIndex,
&unsaved, request->unsaved.size() ? 1 : 0, flags, &clangLine);
// error() << "PARSING" << clangLine;
parseTime = sw.restart();
if (cache->translationUnit) {
RTags::reparseTranslationUnit(cache->translationUnit, &unsaved, request->unsaved.size() ? 1 : 0);
}
reparseTime = sw.elapsed();
if (!cache->translationUnit)
return;
cache->unsavedHash = hash;
cache->lastModified = lastModified;
} else if (cache->unsavedHash != hash || cache->lastModified != lastModified) {
cache->completionsMap.clear();
cache->completionsList.deleteAll();
cache->unsavedHash = hash;
cache->lastModified = lastModified;
} else if (!(request->flags & Refresh)) {
const auto it = cache->completionsMap.find(request->location);
if (it != cache->completionsMap.end()) {
cache->completionsList.moveToEnd(it->second);
error("Found completions (%d) in cache %s:%d:%d",
it->second->candidates.size(), sourceFile.constData(),
request->location.line(), request->location.column());
printCompletions(it->second->candidates, request);
return;
}
}
sw.restart();
const unsigned int completionFlags = (CXCodeComplete_IncludeMacros|CXCodeComplete_IncludeCodePatterns);
CXCodeCompleteResults *results = clang_codeCompleteAt(cache->translationUnit, sourceFile.constData(),
request->location.line(), request->location.column(),
&unsaved, unsaved.Length ? 1 : 0, completionFlags);
completeTime = sw.restart();
if (results) {
std::vector<Completions::Candidate> nodes;
nodes.reserve(results->NumResults);
int nodeCount = 0;
Map<Token, int> tokens;
if (!request->unsaved.isEmpty()) {
tokens = Token::tokenize(request->unsaved.constData(), request->unsaved.size());
// for (Map<Token, int>::const_iterator it = tokens.begin(); it != tokens.end(); ++it) {
// error() << String(it->first.data, it->first.length) << it->second;
// }
}
for (unsigned int i = 0; i < results->NumResults; ++i) {
const CXCursorKind kind = results->Results[i].CursorKind;
if (!(options.options & Server::CompletionsNoFilter) && kind == CXCursor_Destructor)
continue;
const CXCompletionString &string = results->Results[i].CompletionString;
const CXAvailabilityKind availabilityKind = clang_getCompletionAvailability(string);
if (!(options.options & Server::CompletionsNoFilter) && availabilityKind != CXAvailability_Available)
continue;
const int priority = clang_getCompletionPriority(string);
if (size_t(nodeCount) == nodes.size())
nodes.emplace_back();
Completions::Candidate &node = nodes.back();
node.cursorKind = kind;
node.priority = priority;
node.signature.reserve(256);
const int chunkCount = clang_getNumCompletionChunks(string);
bool ok = true;
for (int j=0; j<chunkCount; ++j) {
const CXCompletionChunkKind chunkKind = clang_getCompletionChunkKind(string, j);
if (chunkKind == CXCompletionChunk_TypedText) {
node.completion = RTags::eatString(clang_getCompletionChunkText(string, j));
if (node.completion.size() > 8 && node.completion.startsWith("operator") && !isPartOfSymbol(node.completion.at(8))) {
ok = false;
break;
}
node.signature.append(node.completion);
} else {
node.signature.append(RTags::eatString(clang_getCompletionChunkText(string, j)));
if (chunkKind == CXCompletionChunk_ResultType)
node.signature.append(' ');
}
}
if (ok) {
int ws = node.completion.size() - 1;
while (ws >= 0 && isspace(node.completion.at(ws)))
--ws;
if (ws >= 0) {
node.completion.truncate(ws + 1);
node.signature.replace("\n", "");
node.distance = tokens.value(Token(node.completion.constData(), node.completion.size()), -1);
if (sendDebug)
debug() << node.signature << node.priority << kind
<< node.distance << clang_getCompletionAvailability(string);
++nodeCount;
continue;
}
}
node.completion.clear();
node.signature.clear();
}
if (nodeCount) {
// Sort pointers instead of shuffling candidates around
std::vector<Completions::Candidate*> nodesPtr;
nodesPtr.reserve(nodeCount);
for (auto& n : nodes) nodesPtr.push_back(&n);
std::sort(nodesPtr.begin(), nodesPtr.end(), compareCompletionCandidates);
Completions *&c = cache->completionsMap[request->location];
if (c) {
cache->completionsList.moveToEnd(c);
} else {
enum { MaxCompletionCache = 10 }; // ### configurable?
c = new Completions(request->location);
cache->completionsList.append(c);
while (cache->completionsMap.size() > MaxCompletionCache) {
Completions *cc = cache->completionsList.takeFirst();
cache->completionsMap.remove(cc->location);
delete cc;
}
}
c->candidates.resize(nodeCount);
for (int i=0; i<nodeCount; ++i)
c->candidates[i] = std::move(*nodesPtr[i]);
printCompletions(c->candidates, request);
processTime = sw.elapsed();
warning("Processed %s, parse %d/%d, complete %d, process %d => %d completions (unsaved %d)",
sourceFile.constData(), parseTime, reparseTime, completeTime, processTime, nodeCount, request->unsaved.size());
} else {
printCompletions(List<Completions::Candidate>(), request);
error() << "No completion results available" << request->location << results->NumResults;
}
clang_disposeCodeCompleteResults(results);
}
}
int main() {
return testLog() ;
}
bool IndexerJob::diagnose(int build, int *errorCount)
{
if (errorCount)
*errorCount = 0;
if (!mUnits.at(build).second) {
abort();
return false;
}
List<String> compilationErrors;
const unsigned diagnosticCount = clang_getNumDiagnostics(mUnits.at(build).second);
const unsigned options = Server::instance()->options().options;
for (unsigned i=0; i<diagnosticCount; ++i) {
CXDiagnostic diagnostic = clang_getDiagnostic(mUnits.at(build).second, i);
int logLevel = INT_MAX;
const CXDiagnosticSeverity severity = clang_getDiagnosticSeverity(diagnostic);
switch (severity) {
case CXDiagnostic_Fatal:
case CXDiagnostic_Error:
if (errorCount)
++*errorCount;
logLevel = Error;
break;
case CXDiagnostic_Warning:
logLevel = Warning;
break;
case CXDiagnostic_Note:
logLevel = Debug;
break;
case CXDiagnostic_Ignored:
break;
}
const unsigned diagnosticOptions = (CXDiagnostic_DisplaySourceLocation|
CXDiagnostic_DisplayColumn|
CXDiagnostic_DisplaySourceRanges|
CXDiagnostic_DisplayOption|
CXDiagnostic_DisplayCategoryId|
CXDiagnostic_DisplayCategoryName);
const uint32_t fileId = createLocation(clang_getDiagnosticLocation(diagnostic), 0).fileId();
if (mVisitedFiles.contains(fileId)) {
const String text = RTags::eatString(clang_formatDiagnostic(diagnostic, diagnosticOptions));
if (testLog(logLevel) || testLog(CompilationError)) {
log(logLevel, "%s: %s => %s", mSourceInformation.sourceFile.constData(), mClangLines.at(build).constData(), text.constData());
compilationErrors.append(text);
}
const unsigned fixItCount = clang_getDiagnosticNumFixIts(diagnostic);
RegExp rx;
if (options & Server::IgnorePrintfFixits) {
rx = "^%[A-Za-z0-9]\\+$";
}
for (unsigned f=0; f<fixItCount; ++f) {
CXSourceRange range;
const String string = RTags::eatString(clang_getDiagnosticFixIt(diagnostic, f, &range));
unsigned startOffset;
CXFile file;
clang_getSpellingLocation(clang_getRangeStart(range), &file, 0, 0, &startOffset);
unsigned endOffset;
clang_getSpellingLocation(clang_getRangeEnd(range), 0, 0, 0, &endOffset);
const Location loc(file, startOffset);
if (options & Server::IgnorePrintfFixits && rx.indexIn(string) == 0) {
error("Ignored fixit for %s: Replace %d-%d with [%s]", loc.path().constData(),
startOffset, endOffset, string.constData());
} else {
error("Fixit for %s: Replace %d-%d with [%s]", loc.path().constData(),
startOffset, endOffset, string.constData());
compilationErrors.append(String::format<128>("Fixit for %s: Replace %d-%d with [%s]", loc.path().constData(),
startOffset, endOffset, string.constData()));
mData->fixIts[loc.fileId()].insert(FixIt(startOffset, endOffset, string));
}
}
}
clang_disposeDiagnostic(diagnostic);
}
if (testLog(CompilationError))
sendDiagnostics(compilationErrors);
return !isAborted();
}
CXChildVisitResult IndexerJob::indexVisitor(CXCursor cursor, CXCursor parent, CXClientData data)
{
IndexerJob *job = static_cast<IndexerJob*>(data);
{
MutexLocker lock(&job->mMutex);
if (job->mAborted)
return CXChildVisit_Break;
}
const LastCursorUpdater updater(job->mLastCursor, cursor);
const CXCursorKind kind = clang_getCursorKind(cursor);
const RTags::CursorType type = RTags::cursorType(kind);
if (type == RTags::Other)
return CXChildVisit_Recurse;
bool blocked = false;
Location loc = job->createLocation(cursor, &blocked);
if (blocked) {
return CXChildVisit_Continue;
} else if (loc.isNull()) {
return CXChildVisit_Recurse;
}
if (testLog(VerboseDebug)) {
Log log(VerboseDebug);
log << cursor;
CXCursor ref = clang_getCursorReferenced(cursor);
if (!clang_isInvalid(clang_getCursorKind(ref)) && !clang_equalCursors(ref, cursor)) {
log << "refs" << ref;
}
}
switch (type) {
case RTags::Cursor:
job->handleCursor(cursor, kind, loc);
break;
case RTags::Include:
job->handleInclude(cursor, kind, loc);
break;
case RTags::Reference:
switch (kind) {
case CXCursor_OverloadedDeclRef: {
const int count = clang_getNumOverloadedDecls(cursor);
for (int i=0; i<count; ++i) {
const CXCursor ref = clang_getOverloadedDecl(cursor, i);
job->handleReference(cursor, kind, loc, ref, parent);
}
break; }
case CXCursor_CXXDeleteExpr:
job->handleReference(cursor, kind, loc, findDestructorForDelete(cursor), parent);
break;
default:
job->handleReference(cursor, kind, loc, clang_getCursorReferenced(cursor), parent);
break;
}
break;
case RTags::Other:
assert(0);
break;
}
return CXChildVisit_Recurse;
}
Log::Log(int level)
{
if (testLog(level))
mData.reset(new Data(level));
}
Log::Log(LogLevel level, Flags<LogOutput::LogFlag> flags)
{
if (testLog(level))
mData.reset(new Data(level, flags));
}
CXChildVisitResult ClangIndexer::indexVisitor(CXCursor cursor, CXCursor parent, CXClientData data)
{
ClangIndexer *indexer = static_cast<ClangIndexer*>(data);
// error() << "indexVisitor" << cursor;
// FILE *f = fopen("/tmp/clangindex.log", "a");
// String str;
// Log(&str) << cursor;
// fwrite(str.constData(), 1, str.size(), f);
// fwrite("\n", 1, 1, f);
// fclose(f);
const LastCursorUpdater updater(indexer->mLastCursor, cursor);
const CXCursorKind kind = clang_getCursorKind(cursor);
const RTags::CursorType type = RTags::cursorType(kind);
if (type == RTags::Other)
return CXChildVisit_Recurse;
bool blocked = false;
Location loc = indexer->createLocation(cursor, &blocked);
if (blocked) {
// error() << "blocked" << cursor;
++indexer->mBlocked;
return CXChildVisit_Continue;
} else if (loc.isNull()) {
// error() << "Got null" << cursor;
return CXChildVisit_Recurse;
}
++indexer->mAllowed;
if (indexer->mLogFile) {
String out;
Log(&out) << cursor;
fwrite(out.constData(), 1, out.size(), indexer->mLogFile);
fwrite("\n", 1, 1, indexer->mLogFile);
}
if (testLog(VerboseDebug)) {
Log log(VerboseDebug);
log << cursor;
CXCursor ref = clang_getCursorReferenced(cursor);
if (!clang_isInvalid(clang_getCursorKind(ref)) && !clang_equalCursors(ref, cursor)) {
log << "refs" << ref;
}
}
switch (type) {
case RTags::Cursor:
indexer->handleCursor(cursor, kind, loc);
break;
case RTags::Include:
indexer->handleInclude(cursor, kind, loc);
break;
case RTags::Reference:
switch (kind) {
case CXCursor_OverloadedDeclRef: {
const int count = clang_getNumOverloadedDecls(cursor);
for (int i=0; i<count; ++i) {
const CXCursor ref = clang_getOverloadedDecl(cursor, i);
indexer->handleReference(cursor, kind, loc, ref, parent);
}
break; }
case CXCursor_CXXDeleteExpr:
indexer->handleReference(cursor, kind, loc, findDestructorForDelete(cursor), parent);
break;
case CXCursor_CallExpr: {
// uglehack, see rtags/tests/nestedClassConstructorCallUgleHack/
const CXCursor ref = clang_getCursorReferenced(cursor);
if (clang_getCursorKind(ref) == CXCursor_Constructor
&& clang_getCursorKind(indexer->mLastCursor) == CXCursor_TypeRef
&& clang_getCursorKind(parent) != CXCursor_VarDecl) {
loc = indexer->createLocation(indexer->mLastCursor);
indexer->handleReference(indexer->mLastCursor, kind, loc, ref, parent);
} else {
indexer->handleReference(cursor, kind, loc, ref, parent);
}
break; }
default:
indexer->handleReference(cursor, kind, loc, clang_getCursorReferenced(cursor), parent);
break;
}
break;
case RTags::Other:
assert(0);
break;
}
return CXChildVisit_Recurse;
}
