int main(int argc, char *argv[])
{
CXIndex Index = clang_createIndex(0, 0);
CXTranslationUnit TU;
TU = clang_parseTranslationUnit(Index, 0,
(const char**)argv, argc,
0, 0, CXTranslationUnit_None);
CXCodeCompleteResults *results = clang_codeCompleteAt(TU, argv[1], 20, 7, NULL, 0, clang_defaultCodeCompleteOptions());
unsigned i;
for(i =0; i<results->NumResults; i++)
{
printf("%s",results->Results[i].CompletionString);
}
// clang_disposeString(String);
clang_disposeCodeCompleteResults(results);
clang_disposeTranslationUnit(TU);
clang_disposeIndex(Index);
return 0;
}
unsigned PluginConfiguration::completionFlags() const
{
auto flags = clang_defaultCodeCompleteOptions() | CXCodeComplete_IncludeBriefComments;
if (includeMacros())
{
kDebug(DEBUG_AREA) << "Allow preprocessor MACROS in completion results";
flags |= CXCodeComplete_IncludeMacros;
}
return flags;
}
void Irony::complete(const std::string &file,
unsigned line,
unsigned col,
const std::vector<std::string> &flags,
const std::vector<CXUnsavedFile> &unsavedFiles) {
CXTranslationUnit tu = tuManager_.getOrCreateTU(file, flags, unsavedFiles);
if (tu == nullptr) {
std::cout << "nil\n";
return;
}
if (CXCodeCompleteResults *completions =
clang_codeCompleteAt(tu,
file.c_str(),
line,
col,
const_cast<CXUnsavedFile *>(unsavedFiles.data()),
unsavedFiles.size(),
(clang_defaultCodeCompleteOptions() &
~CXCodeComplete_IncludeCodePatterns)
#if HAS_BRIEF_COMMENTS_IN_COMPLETION
|
CXCodeComplete_IncludeBriefComments
#endif
)) {
if (debug_) {
unsigned numDiags = clang_codeCompleteGetNumDiagnostics(completions);
std::clog << "debug: complete: " << numDiags << " diagnostic(s)\n";
for (unsigned i = 0; i < numDiags; ++i) {
CXDiagnostic diagnostic =
clang_codeCompleteGetDiagnostic(completions, i);
CXString s = clang_formatDiagnostic(
diagnostic, clang_defaultDiagnosticDisplayOptions());
std::clog << clang_getCString(s) << std::endl;
clang_disposeString(s);
clang_disposeDiagnostic(diagnostic);
}
}
clang_sortCodeCompletionResults(completions->Results,
completions->NumResults);
std::cout << "(\n";
// re-use the same buffers to avoid unnecessary allocations
std::string typedtext, brief, resultType, prototype, postCompCar;
std::vector<unsigned> postCompCdr;
for (unsigned i = 0; i < completions->NumResults; ++i) {
CXCompletionResult candidate = completions->Results[i];
CXAvailabilityKind availability =
clang_getCompletionAvailability(candidate.CompletionString);
unsigned priority =
clang_getCompletionPriority(candidate.CompletionString);
unsigned annotationStart = 0;
bool typedTextSet = false;
if (availability == CXAvailability_NotAccessible ||
availability == CXAvailability_NotAvailable) {
continue;
}
typedtext.clear();
brief.clear();
resultType.clear();
prototype.clear();
postCompCar.clear();
postCompCdr.clear();
for (CompletionChunk chunk(candidate.CompletionString); chunk.hasNext();
chunk.next()) {
char ch = 0;
auto chunkKind = chunk.kind();
switch (chunkKind) {
case CXCompletionChunk_ResultType:
resultType = chunk.text();
break;
case CXCompletionChunk_TypedText:
case CXCompletionChunk_Text:
case CXCompletionChunk_Placeholder:
case CXCompletionChunk_Informative:
case CXCompletionChunk_CurrentParameter:
prototype += chunk.text();
break;
case CXCompletionChunk_LeftParen: ch = '('; break;
case CXCompletionChunk_RightParen: ch = ')'; break;
case CXCompletionChunk_LeftBracket: ch = '['; break;
case CXCompletionChunk_RightBracket: ch = ']'; break;
case CXCompletionChunk_LeftBrace: ch = '{'; break;
case CXCompletionChunk_RightBrace: ch = '}'; break;
case CXCompletionChunk_LeftAngle: ch = '<'; break;
case CXCompletionChunk_RightAngle: ch = '>'; break;
case CXCompletionChunk_Comma: ch = ','; break;
case CXCompletionChunk_Colon: ch = ':'; break;
case CXCompletionChunk_SemiColon: ch = ';'; break;
case CXCompletionChunk_Equal: ch = '='; break;
case CXCompletionChunk_HorizontalSpace: ch = ' '; break;
case CXCompletionChunk_VerticalSpace: ch = '\n'; break;
case CXCompletionChunk_Optional:
// ignored for now
break;
}
if (ch != 0) {
prototype += ch;
// commas look better followed by a space
if (ch == ',') {
prototype += ' ';
}
}
if (typedTextSet) {
if (ch != 0) {
postCompCar += ch;
if (ch == ',') {
postCompCar += ' ';
}
} else if (chunkKind == CXCompletionChunk_Text ||
chunkKind == CXCompletionChunk_TypedText) {
postCompCar += chunk.text();
} else if (chunkKind == CXCompletionChunk_Placeholder ||
chunkKind == CXCompletionChunk_CurrentParameter) {
postCompCdr.push_back(postCompCar.size());
postCompCar += chunk.text();
postCompCdr.push_back(postCompCar.size());
}
}
// Consider only the first typed text. The CXCompletionChunk_TypedText
// doc suggests that exactly one typed text will be given but at least
// in Objective-C it seems that more than one can appear, see:
// https://github.com/Sarcasm/irony-mode/pull/78#issuecomment-37115538
if (chunkKind == CXCompletionChunk_TypedText && !typedTextSet) {
typedtext = chunk.text();
// annotation is what comes after the typedtext
annotationStart = prototype.size();
typedTextSet = true;
}
}
#if HAS_BRIEF_COMMENTS_IN_COMPLETION
brief = cxStringToStd(
clang_getCompletionBriefComment(candidate.CompletionString));
#endif
// see irony-completion.el#irony-completion-candidates
std::cout << '(' << support::quoted(typedtext) //
<< ' ' << priority //
<< ' ' << support::quoted(resultType) //
<< ' ' << support::quoted(brief) //
<< ' ' << support::quoted(prototype) //
<< ' ' << annotationStart //
<< " (" << support::quoted(postCompCar);
for (unsigned index : postCompCdr)
std::cout << ' ' << index;
std::cout << ")"
<< ")\n";
}
clang_disposeCodeCompleteResults(completions);
std::cout << ")\n";
}
}
code_complete_results translation_unit::codeCompleteAt(const std::string& filename, unsigned line, unsigned column, const std::vector<unsaved_file>& unsaved)
{
auto unsaved_files = convert_unsaved_files(unsaved);
auto options = clang_defaultCodeCompleteOptions();
return { clang_codeCompleteAt(tu, filename.c_str(), line, column, unsaved_files.data(), unsaved_files.size(), options) };
}
void ClangWorkerThread::ProcessRequest(ThreadRequest* request)
{
// Send start event
PostEvent(wxEVT_CLANG_PCH_CACHE_STARTED, "");
ClangThreadRequest* task = dynamic_cast<ClangThreadRequest*>(request);
wxASSERT_MSG(task, "ClangWorkerThread: NULL task");
{
// A bit of optimization
wxCriticalSectionLocker locker(m_criticalSection);
if(task->GetContext() == CTX_CachePCH && m_cache.Contains(task->GetFileName())) {
// Nothing to be done here
PostEvent(wxEVT_CLANG_PCH_CACHE_ENDED, task->GetFileName());
return;
}
}
CL_DEBUG(wxT("==========> [ ClangPchMakerThread ] ProcessRequest started: %s"), task->GetFileName().c_str());
CL_DEBUG(wxT("ClangWorkerThread:: processing request %d"), (int)task->GetContext());
ClangCacheEntry cacheEntry = findEntry(task->GetFileName());
CXTranslationUnit TU = cacheEntry.TU;
CL_DEBUG(wxT("ClangWorkerThread:: found cached TU: %p"), (void*)TU);
bool reparseRequired = true;
if(!TU) {
// First time creating the TU
TU = DoCreateTU(task->GetIndex(), task, true);
reparseRequired = false;
cacheEntry.lastReparse = time(NULL);
cacheEntry.TU = TU;
cacheEntry.sourceFile = task->GetFileName();
}
if(!TU) {
CL_DEBUG(wxT("Failed to parse Translation UNIT..."));
PostEvent(wxEVT_CLANG_TU_CREATE_ERROR, task->GetFileName());
return;
}
if(reparseRequired && task->GetContext() == ::CTX_ReparseTU) {
DoSetStatusMsg(wxString::Format(wxT("clang: re-parsing file %s..."), task->GetFileName().c_str()));
// We need to reparse the TU
CL_DEBUG(wxT("Calling clang_reparseTranslationUnit... [CTX_ReparseTU]"));
if(clang_reparseTranslationUnit(TU, 0, NULL, clang_defaultReparseOptions(TU)) == 0) {
CL_DEBUG(wxT("Calling clang_reparseTranslationUnit... done [CTX_ReparseTU]"));
cacheEntry.lastReparse = time(NULL);
} else {
CL_DEBUG(wxT("An error occured during reparsing of the TU for file %s. TU: %p"),
task->GetFileName().c_str(),
(void*)TU);
// The only thing that left to be done here, is to dispose the TU
clang_disposeTranslationUnit(TU);
PostEvent(wxEVT_CLANG_TU_CREATE_ERROR, task->GetFileName());
return;
}
}
// Construct a cache-returner class
// which makes sure that the TU is cached
// when we leave the current scope
CacheReturner cr(this, cacheEntry);
// Prepare the 'End' event
wxCommandEvent eEnd(wxEVT_CLANG_PCH_CACHE_ENDED);
ClangThreadReply* reply = new ClangThreadReply;
reply->context = task->GetContext();
reply->filterWord = task->GetFilterWord();
reply->filename = task->GetFileName().c_str();
reply->results = NULL;
wxFileName realFileName(reply->filename);
if(realFileName.GetFullName().StartsWith(CODELITE_CLANG_FILE_PREFIX)) {
realFileName.SetFullName(realFileName.GetFullName().Mid(strlen(CODELITE_CLANG_FILE_PREFIX)));
}
reply->filename = realFileName.GetFullPath();
if(task->GetContext() == CTX_CodeCompletion || task->GetContext() == CTX_WordCompletion ||
task->GetContext() == CTX_Calltip) {
CL_DEBUG(wxT("Calling clang_codeCompleteAt..."));
ClangThreadRequest::List_t usList = task->GetModifiedBuffers();
usList.push_back(std::make_pair(task->GetFileName(), task->GetDirtyBuffer()));
ClangUnsavedFiles usf(usList);
CL_DEBUG(wxT("Location: %s:%u:%u"), task->GetFileName().c_str(), task->GetLine(), task->GetColumn());
reply->results = clang_codeCompleteAt(TU,
cstr(task->GetFileName()),
task->GetLine(),
task->GetColumn(),
usf.GetUnsavedFiles(),
usf.GetCount(),
clang_defaultCodeCompleteOptions()
#if HAS_LIBCLANG_BRIEFCOMMENTS
|
CXCodeComplete_IncludeBriefComments
#endif
);
cacheEntry.lastReparse = time(NULL);
CL_DEBUG(wxT("Calling clang_codeCompleteAt... done"));
wxString displayTip;
bool hasErrors(false);
if(reply->results) {
unsigned maxErrorToDisplay = 10;
std::set<wxString> errorMessages;
unsigned errorCount = clang_codeCompleteGetNumDiagnostics(reply->results);
// Collect all errors / fatal errors and report them back to user
for(unsigned i = 0; i < errorCount; i++) {
CXDiagnostic diag = clang_codeCompleteGetDiagnostic(reply->results, i);
CXDiagnosticSeverity severity = clang_getDiagnosticSeverity(diag);
if(!hasErrors) {
hasErrors = (severity == CXDiagnostic_Error || severity == CXDiagnostic_Fatal);
}
if(severity == CXDiagnostic_Error || severity == CXDiagnostic_Fatal || severity == CXDiagnostic_Note) {
CXString diagStr = clang_getDiagnosticSpelling(diag);
wxString wxDiagString = wxString(clang_getCString(diagStr), wxConvUTF8);
// Collect up to 10 error messages
// and dont collect the same error twice
if(errorMessages.find(wxDiagString) == errorMessages.end() &&
errorMessages.size() <= maxErrorToDisplay) {
errorMessages.insert(wxDiagString);
displayTip << wxDiagString.c_str() << wxT("\n");
}
clang_disposeString(diagStr);
}
clang_disposeDiagnostic(diag);
}
CL_DEBUG(wxT("Found %u matches"), reply->results->NumResults);
ClangUtils::printCompletionDiagnostics(reply->results);
}
if(!displayTip.IsEmpty() && hasErrors) {
// Send back the error messages
reply->errorMessage << "clang: " << displayTip;
reply->errorMessage.RemoveLast();
// Free the results
clang_disposeCodeCompleteResults(reply->results);
reply->results = NULL;
}
// Send the event
eEnd.SetClientData(reply);
EventNotifier::Get()->AddPendingEvent(eEnd);
} else if(task->GetContext() == CTX_GotoDecl || task->GetContext() == CTX_GotoImpl) {
// Check to see if the file was modified since it was last reparsed
// If it does, we need to re-parse it again
wxFileName fnSource(cacheEntry.sourceFile);
time_t fileModificationTime = fnSource.GetModificationTime().GetTicks();
time_t lastReparseTime = cacheEntry.lastReparse;
if(fileModificationTime > lastReparseTime) {
// The file needs to be re-parsed
DoSetStatusMsg(wxString::Format(wxT("clang: re-parsing file %s...\n"), cacheEntry.sourceFile));
// Try reparsing the TU
ClangThreadRequest::List_t usList = task->GetModifiedBuffers();
usList.push_back(std::make_pair(task->GetFileName(), task->GetDirtyBuffer()));
ClangUnsavedFiles usf(usList);
if(clang_reparseTranslationUnit(
TU, usf.GetCount(), usf.GetUnsavedFiles(), clang_defaultReparseOptions(TU)) != 0) {
// Failed to reparse
cr.SetCancelled(true); // cancel the re-caching of the TU
DoSetStatusMsg(
wxString::Format("clang: clang_reparseTranslationUnit '%s' failed\n", cacheEntry.sourceFile));
clang_disposeTranslationUnit(TU);
wxDELETE(reply);
PostEvent(wxEVT_CLANG_TU_CREATE_ERROR, task->GetFileName());
return;
}
DoSetStatusMsg(
wxString::Format("clang: clang_reparseTranslationUnit '%s' - done\n", cacheEntry.sourceFile));
// Update the 'lastReparse' field
cacheEntry.lastReparse = time(NULL);
}
bool success = DoGotoDefinition(TU, task, reply);
if(success) {
eEnd.SetClientData(reply);
EventNotifier::Get()->AddPendingEvent(eEnd);
} else {
DoSetStatusMsg(wxT("clang: no matches were found"));
CL_DEBUG(wxT("Clang Goto Decl/Impl: could not find a cursor matching for position %s:%d:%d"),
task->GetFileName().c_str(),
(int)task->GetLine(),
(int)task->GetColumn());
// Failed, delete the 'reply' allocatd earlier
wxDELETE(reply);
PostEvent(wxEVT_CLANG_TU_CREATE_ERROR, task->GetFileName());
}
} else {
wxDELETE(reply);
PostEvent(wxEVT_CLANG_PCH_CACHE_ENDED, task->GetFileName());
}
}