std::string tokenize_as_vimson(char const* const* args, size_t const argc)
{
CXIndex index = clang_createIndex(/*excludeDeclsFromPCH*/ 1, /*displayDiagnostics*/0);
translation_unit = clang_parseTranslationUnit(index, file_name.c_str(), args, argc, NULL, 0, CXTranslationUnit_Incomplete);
if (translation_unit == NULL) {
clang_disposeIndex(index);
return "{}";
}
auto file_range = get_range_whole_file();
if (clang_Range_isNull(file_range)) {
clang_disposeTranslationUnit(translation_unit);
clang_disposeIndex(index);
return "{}";
}
CXToken *tokens_;
unsigned int num_tokens;
clang_tokenize(translation_unit, file_range, &tokens_, &num_tokens);
std::vector<CXToken> tokens(tokens_, tokens_ + num_tokens);
auto result = make_vimson_from_tokens(tokens);
clang_disposeTokens(translation_unit, tokens_, num_tokens);
clang_disposeTranslationUnit(translation_unit);
clang_disposeIndex(index);
return result;
}
void ClangParser::finish()
{
static bool clangAssistedParsing = Config_getBool(CLANG_ASSISTED_PARSING);
if (!clangAssistedParsing) return;
if (p->tu)
{
//printf("ClangParser::finish()\n");
delete[] p->cursors;
clang_disposeTokens(p->tu,p->tokens,p->numTokens);
clang_disposeTranslationUnit(p->tu);
clang_disposeIndex(p->index);
p->fileMapping.clear();
p->tokens = 0;
p->numTokens = 0;
p->cursors = 0;
}
for (uint i=0;i<p->numFiles;i++)
{
free((void *)p->ufs[i].Filename);
}
delete[] p->ufs;
delete[] p->sources;
p->ufs = 0;
p->sources = 0;
p->numFiles = 0;
p->tu = 0;
}
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();
});
}
void ClangParser::finish()
{
if (p->tu) {
delete[] p->cursors;
clang_disposeTokens(p->tu, p->tokens, p->numTokens);
clang_disposeTranslationUnit(p->tu);
clang_disposeIndex(p->index);
p->fileMapping.clear();
p->tokens = 0;
p->numTokens = 0;
p->cursors = 0;
}
for (uint i = 0; i < p->numFiles; i++) {
free((void *)p->ufs[i].Filename);
}
delete[] p->ufs;
delete[] p->sources;
p->ufs = 0;
p->sources = 0;
p->numFiles = 0;
p->tu = 0;
}
void TearDown() override {
clang_disposeTranslationUnit(ClangTU);
clang_disposeIndex(Index);
for (const std::string &Path : Files)
llvm::sys::fs::remove(Path);
llvm::sys::fs::remove(TestDir);
}
index::~index()
{
/* The index must not be destroyed until all of the translation units created
* within that index have been destroyed.*/
tus.clear();
clang_disposeIndex(idx);
}
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;
}
void server_main()
{
struct sigaction sa;
int sock;
sock_path = get_socket_path();
sock = create_server_socket(sock_path);
if (sock == -1) {
fprintf(stderr, "Error! Failed to create a server socket: %s\n",
sock_path->data);
exit(1);
}
sa.sa_handler = handle_sigint;
sa.sa_flags = 0;
sigaction(SIGINT, &sa, 0);
clang_index = clang_createIndex(0, 0);
server_loop(sock);
if (clang_tu)
clang_disposeTranslationUnit(clang_tu);
clang_disposeIndex(clang_index);
close(sock);
unlink(sock_path->data);
str_free(sock_path);
}
Server::~Server()
{
clear();
assert(sInstance == this);
sInstance = 0;
Messages::cleanup();
clang_disposeIndex(mIndex);
}
ReflectionParser::~ReflectionParser(void)
{
if (m_translationUnit)
clang_disposeTranslationUnit( m_translationUnit );
if (m_index)
clang_disposeIndex( m_index );
}
ClangIndexer::~ClangIndexer()
{
if (mLogFile)
fclose(mLogFile);
if (mClangUnit)
clang_disposeTranslationUnit(mClangUnit);
if (mIndex)
clang_disposeIndex(mIndex);
}
Tokenizer::~Tokenizer()
{
CLangAutoLock lock(mCLangLock, __LINE__, this);
if(mTransUnit)
{
clang_disposeTranslationUnit(mTransUnit);
clang_disposeIndex(mContextIndex);
}
}
void CompletionThread::run()
{
mIndex = clang_createIndex(0, 1);
while (true) {
Request *request = 0;
Dump *dump = 0;
{
std::unique_lock<std::mutex> lock(mMutex);
while (!mShutdown && mPending.isEmpty() && !mDump) {
mCondition.wait(lock);
}
if (mShutdown) {
for (auto it = mPending.begin(); it != mPending.end(); ++it) {
delete *it;
}
mPending.clear();
if (mDump) {
std::unique_lock<std::mutex> lock(mDump->mutex);
mDump->done = true;
mDump->cond.notify_one();
mDump = 0;
}
break;
} else if (mDump) {
std::swap(dump, mDump);
} else {
assert(!mPending.isEmpty());
request = mPending.takeFirst();
}
}
if (dump) {
std::unique_lock<std::mutex> lock(dump->mutex);
Log out(&dump->string);
for (SourceFile *cache = mCacheList.first(); cache; cache = cache->next) {
out << cache->source << "\nhash:" << cache->unsavedHash
<< "lastModified:" << cache->lastModified
<< "translationUnit:" << cache->translationUnit << "\n";
for (Completions *completion = cache->completionsList.first(); completion; completion = completion->next) {
out << " " << completion->location.key() << "\n";
for (const auto &c : completion->candidates) {
out << " " << c.completion << c.signature << c.priority << c.distance
<< RTags::eatString(clang_getCursorKindSpelling(c.cursorKind)) << "\n";
}
}
}
dump->done = true;
dump->cond.notify_one();
} else {
assert(request);
process(request);
delete request;
}
}
clang_disposeIndex(mIndex);
mIndex = 0;
}
int perform_test_load_tu(const char *file, const char *filter,
const char *prefix, CXCursorVisitor Visitor,
PostVisitTU PV) {
CXIndex Idx;
CXTranslationUnit TU;
int result;
Idx = clang_createIndex(/* excludeDeclsFromPCH */
!strcmp(filter, "local") ? 1 : 0,
/* displayDiagnosics=*/1);
if (!CreateTranslationUnit(Idx, file, &TU)) {
clang_disposeIndex(Idx);
return 1;
}
result = perform_test_load(Idx, TU, filter, prefix, Visitor, PV);
clang_disposeIndex(Idx);
return result;
}
ClangCompleter::~ClangCompleter() {
// We need to destroy all TUs before calling clang_disposeIndex because
// the translation units need to be destroyed before the index is destroyed.
// Technically, a thread could still be holding onto a shared_ptr<TU> object
// when we destroy the clang index, but since we're shutting down, we don't
// really care.
// In practice, this situation shouldn't happen because the server threads are
// Python deamon threads and will all be killed before the main thread exits.
translation_unit_store_.RemoveAll();
clang_disposeIndex( clang_index_ );
}
int main(int argc, char * argv[])
{
CXIndex index = clang_createIndex(0, 0);
CXTranslationUnit txUnit = clang_parseTranslationUnit(index, 0, (const char * const *) argv, argc, 0, 0, CXTranslationUnit_None);
CXCursor cur = clang_getTranslationUnitCursor(txUnit);
clang_visitChildren(cur, visitor, NULL);
clang_disposeTranslationUnit(txUnit);
clang_disposeIndex(index);
return 0;
}
int perform_test_load_source(int argc, const char **argv,
const char *filter, CXCursorVisitor Visitor,
PostVisitTU PV) {
const char *UseExternalASTs =
getenv("CINDEXTEST_USE_EXTERNAL_AST_GENERATION");
CXIndex Idx;
CXTranslationUnit TU;
struct CXUnsavedFile *unsaved_files = 0;
int num_unsaved_files = 0;
int result;
Idx = clang_createIndex(/* excludeDeclsFromPCH */
!strcmp(filter, "local") ? 1 : 0,
/* displayDiagnosics=*/1);
if (UseExternalASTs && strlen(UseExternalASTs))
clang_setUseExternalASTGeneration(Idx, 1);
if (parse_remapped_files(argc, argv, 0, &unsaved_files, &num_unsaved_files)) {
clang_disposeIndex(Idx);
return -1;
}
TU = clang_createTranslationUnitFromSourceFile(Idx, 0,
argc - num_unsaved_files,
argv + num_unsaved_files,
num_unsaved_files,
unsaved_files);
if (!TU) {
fprintf(stderr, "Unable to load translation unit!\n");
free_remapped_files(unsaved_files, num_unsaved_files);
clang_disposeIndex(Idx);
return 1;
}
result = perform_test_load(Idx, TU, filter, NULL, Visitor, PV);
free_remapped_files(unsaved_files, num_unsaved_files);
clang_disposeIndex(Idx);
return result;
}
int main(int argc, const char* const argv[]){
if (argc < 2) {
printf("Usage: %s header.h\n", argv[0]);
printf("Standard clang arguments (-I, -D, etc.) may be used\n");
exit(1);
}
unsigned i;
char filename[] = "ffigen.tmp.XXXXXX";
int fd = mkstemp(filename);
FILE* file = fdopen(fd, "w");
fprintf(file, "#define _SIZE_T\n");
fprintf(file, "#define _PTRDIFF_T\n");
fprintf(file, "typedef __SIZE_TYPE__ size_t;\n");
fprintf(file, "typedef __PTRDIFF_TYPE__ ptrdiff_t;\n");
fprintf(file, "#include <%s>\n", argv[1]);
fclose(file);
int clang_argc = argc + 1;
const char** clang_argv = malloc(sizeof(char*) * clang_argc);
clang_argv[0] = "-x";
clang_argv[1] = "c";
clang_argv[2] = filename;
for (i=3; i < clang_argc; i++) {
clang_argv[i] = argv[i-1];
}
CXIndex Index = clang_createIndex(0, 0);
TU = clang_parseTranslationUnit(Index, 0, clang_argv, clang_argc,
0, 0, CXTranslationUnit_DetailedPreprocessingRecord);
json_t* json = json_object();
clang_visitChildren(clang_getTranslationUnitCursor(TU), visit_program, (CXClientData)json);
json_dumpf(json, stdout, JSON_INDENT(2) | JSON_PRESERVE_ORDER);
printf("\n");
json_decref(json);
for (i=0; i<clang_getNumDiagnostics(TU); i++) {
putstring(clang_formatDiagnostic(clang_getDiagnostic(TU, i), clang_defaultDiagnosticDisplayOptions()));
}
clang_disposeTranslationUnit(TU);
clang_disposeIndex(Index);
free(clang_argv);
unlink(filename);
return 0;
}
void TestCases::ClangTest() {
#ifdef ENABLE_CLANG_COMPLETION
std::cout << "checking to see if libclang/libclang.dll works" << std::endl;
int argc = 1;
char* argv[] = {"--version"};
CXIndex index = clang_createIndex(0, 0);
CXTranslationUnit tu = clang_parseTranslationUnit(index, 0, argv, argc, 0, 0,
CXTranslationUnit_None);
clang_disposeTranslationUnit(tu);
clang_disposeIndex(index);
#endif
}
/* When emacs buffer is killed, a SHUTDOWN message is sent automatically by a hook
function to inform the completion server (this program) to terminate. */
void completion_doShutdown(completion_Session *session, FILE *fp)
{
(void) fp; /* this parameter is unused, the server will shutdown
* directly without sending any messages to its client */
/* free clang parser infrastructures */
clang_disposeTranslationUnit(session->cx_tu);
clang_disposeIndex(session->cx_index);
/* free session properties */
completion_freeCmdlineArgs(session);
free(session->src_buffer);
exit(0); /* terminate completion process */
}
int main(int argc, char *argv[])
{
CXIndex Index = clang_createIndex(0, 0);
CXTranslationUnit TU = clang_parseTranslationUnit(Index, 0,
(const char**)argv, argc,
0, 0, CXTranslationUnit_None);
struct self whole;
whole.
clang_disposeTranslationUnit(TU);
clang_disposeIndex(Index);
return 0;
}
int perform_code_completion(int argc, const char **argv) {
const char *input = argv[1];
char *filename = 0;
unsigned line;
unsigned column;
CXIndex CIdx;
int errorCode;
struct CXUnsavedFile *unsaved_files = 0;
int num_unsaved_files = 0;
CXCodeCompleteResults *results = 0;
input += strlen("-code-completion-at=");
if ((errorCode = parse_file_line_column(input, &filename, &line, &column,
0, 0)))
return errorCode;
if (parse_remapped_files(argc, argv, 2, &unsaved_files, &num_unsaved_files))
return -1;
CIdx = clang_createIndex(0, 1);
results = clang_codeComplete(CIdx,
argv[argc - 1], argc - num_unsaved_files - 3,
argv + num_unsaved_files + 2,
num_unsaved_files, unsaved_files,
filename, line, column);
if (results) {
unsigned i, n = results->NumResults;
for (i = 0; i != n; ++i)
print_completion_result(results->Results + i, stdout);
n = clang_codeCompleteGetNumDiagnostics(results);
for (i = 0; i != n; ++i) {
CXDiagnostic diag = clang_codeCompleteGetDiagnostic(results, i);
PrintDiagnostic(diag);
clang_disposeDiagnostic(diag);
}
clang_disposeCodeCompleteResults(results);
}
clang_disposeIndex(CIdx);
free(filename);
free_remapped_files(unsaved_files, num_unsaved_files);
return 0;
}
void DumpThread::run()
{
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);
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);
EventLoop::mainEventLoop()->callLaterMove(std::bind((bool(Connection::*)(Message&&))&Connection::send, mConnection, std::placeholders::_1),
FinishMessage());
}
int main(int argc, char *argv[])
{
auto index = clang_createIndex(0, 0);
std::vector<std::string> default_args = { {"-x"}, {"c++"}, {"-std=c++11"} };
std::string filename;
ArgList arglist( default_args );
if ( argc > 1 ) {
arglist = ArgList( argc - 2, argv + 1 );
filename = argv[argc - 1];
} else {
filename = argv[1];
}
TUnit tu( index, filename );
if ( !tu.parse( arglist.count(), arglist ) ) {
std::cout << "Translation Unit Initial Parse Failed!\n";
}
std::string input;
std::vector<char> filebuffer;
while( std::getline( std::cin, input ) ) {
if ( input == "REPARSE" ) {
filebuffer = ReparseSource();
CXUnsavedFile unsaved_file = { filename.c_str(),
filebuffer.data(),
filebuffer.size() };
// std::cout << "Size = " << filebuffer.size()
// << "Contents:\n" << filebuffer.data()
// << "\n";
if ( tu.parse( std::vector<CXUnsavedFile>( 1, unsaved_file ) ) ) {
TokenizeSource( tu.handle() );
} else {
std::cout << "Reparse FAILED!\n" << end_pattern << "\n";
}
}
}
clang_disposeIndex( index );
return 0;
}
ClangDriver::~ClangDriver()
{
// Disconnect all events before we perform anything elase
EventNotifier::Get()->Disconnect(
wxEVT_CLANG_PCH_CACHE_ENDED, wxCommandEventHandler(ClangDriver::OnPrepareTUEnded), NULL, this);
EventNotifier::Get()->Disconnect(
wxEVT_CLANG_PCH_CACHE_CLEARED, wxCommandEventHandler(ClangDriver::OnCacheCleared), NULL, this);
EventNotifier::Get()->Disconnect(
wxEVT_CLANG_TU_CREATE_ERROR, wxCommandEventHandler(ClangDriver::OnTUCreateError), NULL, this);
EventNotifier::Get()->Disconnect(
wxEVT_WORKSPACE_LOADED, wxCommandEventHandler(ClangDriver::OnWorkspaceLoaded), NULL, this);
m_pchMakerThread.Stop();
m_pchMakerThread.ClearCache(); // clear cache and dispose all translation units
#ifdef __WXMSW__
m_clangCleanerThread.Stop();
#endif
clang_disposeIndex(m_index);
}
int main(int argc, char* argv[])
{
CXString version = clang_getClangVersion();
printf("%s\n", clang_getCString(version));
clang_disposeString(version);
CXIndex index = clang_createIndex(1, 1);
CXTranslationUnit tu = clang_createTranslationUnit(index, argv[1]);
if (tu) {
clang_visitChildren(clang_getTranslationUnitCursor(tu), visitor, argv[2]);
clang_disposeTranslationUnit(tu);
}
clang_disposeIndex(index);
return 0;
}
int main(int argc, char **argv)
{
if (argc < 2)
return 1;
CXIndex index = clang_createIndex(1, 1);
const char * const *args = 0;
if (argc > 2)
args = (const char *const *)&argv[2];
CXTranslationUnit unit = clang_parseTranslationUnit(index, argv[1], args, argc - 2,
0, 0, clang_defaultEditingTranslationUnitOptions());
if (unit) {
int indent = 0;
clang_visitChildren(clang_getTranslationUnitCursor(unit), visit, &indent);
const unsigned int diagnosticCount = clang_getNumDiagnostics(unit);
unsigned int i;
for (i=0; i<diagnosticCount; ++i) {
CXDiagnostic diagnostic = clang_getDiagnostic(unit, i);
const unsigned int diagnosticOptions = (CXDiagnostic_DisplaySourceLocation|
CXDiagnostic_DisplayColumn|
CXDiagnostic_DisplaySourceRanges|
CXDiagnostic_DisplayOption|
CXDiagnostic_DisplayCategoryId|
CXDiagnostic_DisplayCategoryName);
CXString diagnosticText = clang_formatDiagnostic(diagnostic, diagnosticOptions);
const char *cstr = clang_getCString(diagnosticText);
if (cstr)
printf("%s\n", cstr);
clang_disposeString(diagnosticText);
}
clang_disposeTranslationUnit(unit);
}
clang_disposeIndex(index);
return 0;
}
void IndexerJob::execute()
{
if (isAborted())
return;
mTimer.start();
mData.reset(new IndexData);
if (mType == Dump) {
assert(id() != -1);
if (shared_ptr<Project> p = project()) {
for (int i=0; i<mSourceInformation.builds.size(); ++i) {
parse(i);
if (mUnits.at(i).second) {
DumpUserData u = { 0, this, !(queryFlags() & QueryMessage::NoContext) };
clang_visitChildren(clang_getTranslationUnitCursor(mUnits.at(i).second),
IndexerJob::dumpVisitor, &u);
}
}
}
} else {
{
MutexLocker lock(&mMutex);
mStarted = true;
}
int errorCount = 0;
int unitCount = 0;
const int buildCount = mSourceInformation.builds.size();
for (int i=0; i<buildCount; ++i) {
if (!parse(i)) {
goto end;
}
if (mUnits.at(i).second)
++unitCount;
}
mParseTime = time(0);
for (int i=0; i<buildCount; ++i) {
int err = 0;
if (!visit(i) || !diagnose(i, &err))
goto end;
errorCount += err;
}
{
mData->message += mSourceInformation.sourceFile.toTilde();
if (buildCount > 1)
mData->message += String::format<16>(" (%d builds)", buildCount);
if (!unitCount) {
mData->message += " error";
} else if (unitCount != buildCount) {
mData->message += String::format<16>(" (%d errors, %d ok)", buildCount - unitCount, unitCount);
}
mData->message += String::format<16>(" in %sms. ", String::number(mTimer.elapsed()).constData());
if (unitCount) {
mData->message += String::format<1024>("(%d syms, %d symNames, %d refs, %d deps, %d files)",
mData->symbols.size(), mData->symbolNames.size(), mData->references.size(),
mData->dependencies.size(), mVisitedFiles.size());
} else if (mData->dependencies.size()) {
mData->message += String::format<16>("(%d deps)", mData->dependencies.size());
}
if (mType == Dirty)
mData->message += " (dirty)";
}
end:
shared_ptr<Project> p = project();
if (p) {
shared_ptr<IndexerJob> job = static_pointer_cast<IndexerJob>(shared_from_this());
p->onJobFinished(job);
}
}
for (int i=0; i<mUnits.size(); ++i) {
if (mUnits.at(i).first)
clang_disposeIndex(mUnits.at(i).first);
if (mUnits.at(i).second)
clang_disposeTranslationUnit(mUnits.at(i).second);
}
mUnits.clear();
}
TranslationUnitData::~TranslationUnitData()
{
clang_disposeTranslationUnit(translationUnit);
clang_disposeIndex(index);
}
Index::~Index()
{
clang_disposeIndex(index_);
}
