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 TranslationUnitUpdater::createIndexIfNeeded()
{
if (!m_cxIndex) {
const bool displayDiagnostics = isVerboseModeEnabled();
m_cxIndex = clang_createIndex(1, displayDiagnostics);
}
}
const char* libclang_vim::at_specific_location(
const location_tuple& location_tuple,
const std::function<std::string(CXCursor const&)>& predicate) {
static std::string vimson;
char const* file_name = location_tuple.file.c_str();
auto const args_ptrs = get_args_ptrs(location_tuple.args);
cxindex_ptr index =
clang_createIndex(/*excludeDeclsFromPCH*/ 1, /*displayDiagnostics*/ 0);
std::vector<CXUnsavedFile> unsaved_files =
create_unsaved_files(location_tuple);
cxtranslation_unit_ptr translation_unit(clang_parseTranslationUnit(
index, file_name, args_ptrs.data(), args_ptrs.size(),
unsaved_files.data(), unsaved_files.size(),
CXTranslationUnit_Incomplete));
if (!translation_unit)
return "{}";
CXFile file = clang_getFile(translation_unit, file_name);
auto const location = clang_getLocation(
translation_unit, file, location_tuple.line, location_tuple.col);
CXCursor const cursor = clang_getCursor(translation_unit, location);
vimson = predicate(cursor);
return vimson.c_str();
}
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);
}
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;
}
CXTranslationUnit CodeFile::ParseTranslationUnit() {
/* if (translationUnit) {
clang_disposeTranslationUnit(translationUnit);
}
*/
std::vector<const char*> arguments;
arguments.push_back("c++");
arguments.push_back("-std=c++11");
arguments.push_back("-stdlib=libc++");
arguments.push_back("-I/Users/Jeppe/Downloads/clang+llvm-3.7.0-x86_64-apple-darwin/include/c++/v1");
arguments.push_back("-I/Users/Jeppe/Downloads/clang+llvm-3.7.0-x86_64-apple-darwin/lib/clang/3.7.0/include");
//arguments.push_back("-I/usr/include");
//arguments.push_back("-I/usr/include/c++/4.2.1/");
arguments.push_back("-I/Projects/PocketEngine/Pocket/Data/");
arguments.push_back("-I/Projects/PocketEngine/Pocket/ComponentSystem/");
arguments.push_back("-I/Projects/PocketEngine/Pocket/ComponentSystem/Meta/");
CXIndex index = clang_createIndex(0,1);
CXTranslationUnit tu = clang_parseTranslationUnit(index, path.c_str(), &arguments[0], (int)arguments.size(), NULL, 0, 0);
return tu;
}
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 GmacsPreprocessor::compile(const QString &filename, const QTextCursor &cursor)
{
if (filename.isEmpty()) return;
idx = clang_createIndex(1, 0);
if (!idx) fprintf(stderr, "ERROR: createIndex failed\n");
int clang_arg_size = include_dirs_size;
char *clang_arg_ptr[clang_arg_size];
for (int i = 0; i < clang_arg_size; i++) {
clang_arg_ptr[i] = include_dirs->at(i);
//fprintf(stderr, "dirs = [%s]\n", clang_arg_ptr[i]);
}
//fprintf(stderr, "filename = [%s]\n", filename);
QString document = cursor.document()->toPlainText();
unsaved_file = new CXUnsavedFile();
//unsaved_file->Filename = filename;
//unsaved_file->Contents = document.toLocal8Bit().data();
//unsaved_file->Length = document.size();
const char *name = filename.toLocal8Bit().data();
unit = CLANG_PARSE(idx, name, clang_arg_ptr, clang_arg_size, NULL);//unsaved_file);
if (!unit) {
fprintf(stderr, "ERROR parseTranslationUnit failed\n");
} else {
CLANG_REPARSE(unit, NULL);//unsaved_file);
}
}
static void
ide_clang_service_start (IdeService *service)
{
IdeClangService *self = (IdeClangService *)service;
g_return_if_fail (IDE_IS_CLANG_SERVICE (self));
g_return_if_fail (!self->index);
self->cancellable = g_cancellable_new ();
self->units_cache = egg_task_cache_new ((GHashFunc)ide_file_hash,
(GEqualFunc)ide_file_equal,
g_object_ref,
g_object_unref,
g_object_ref,
g_object_unref,
DEFAULT_EVICTION_MSEC,
ide_clang_service_get_translation_unit_worker,
g_object_ref (self),
g_object_unref);
self->index = clang_createIndex (0, 0);
clang_CXIndex_setGlobalOptions (self->index,
CXGlobalOpt_ThreadBackgroundPriorityForAll);
}
void SetUp() override {
llvm::SmallString<256> Dir;
ASSERT_FALSE(llvm::sys::fs::createUniqueDirectory("libclang-test", Dir));
TestDir = Dir.str();
TUFlags = CXTranslationUnit_DetailedPreprocessingRecord |
clang_defaultEditingTranslationUnitOptions();
Index = clang_createIndex(0, 0);
}
ClangCompleter::ClangCompleter()
: clang_index_( clang_createIndex( 0, 0 ) ),
translation_unit_store_( clang_index_ ) {
// The libclang docs don't say what is the default value for crash recovery.
// I'm pretty sure it's turned on by default, but I'm not going to take any
// chances.
clang_toggleCrashRecovery( true );
}
int main(int argc, const char* argv[]) {
if (argc < 4) {
std::cerr << "Usage:\n"
<< " " << argv[0] << " <dbFilename> <indexFilename> [<options>] <sourceFilename>\n";
return 1;
}
const char* dbFilename = argv[1];
const char* indexFilename = argv[2];
const char* sourceFilename = argv[argc-1];
// Set up the clang translation unit
CXIndex cxindex = clang_createIndex(0, 0);
CXTranslationUnit tu = clang_parseTranslationUnit(
cxindex, 0,
argv + 3, argc - 3, // Skip over dbFilename and indexFilename
0, 0,
CXTranslationUnit_None);
// Print any errors or warnings
int n = clang_getNumDiagnostics(tu);
if (n > 0) {
int nErrors = 0;
for (unsigned i = 0; i != n; ++i) {
CXDiagnostic diag = clang_getDiagnostic(tu, i);
CXString string = clang_formatDiagnostic(diag, clang_defaultDiagnosticDisplayOptions());
fprintf(stderr, "%s\n", clang_getCString(string));
if (clang_getDiagnosticSeverity(diag) == CXDiagnostic_Error
|| clang_getDiagnosticSeverity(diag) == CXDiagnostic_Fatal)
nErrors++;
}
}
// Create the index
EverythingIndexer visitor(sourceFilename);
clang_visitChildren(
clang_getTranslationUnitCursor(tu),
&visitorFunction,
&visitor);
ClicIndex& index = visitor.usrToReferences;
// OK, now write the index to a compressed file
std::ofstream fout(indexFilename);
boost::iostreams::filtering_stream<boost::iostreams::output> zout;
zout.push(boost::iostreams::gzip_compressor());
zout.push(fout);
printIndex(zout, index);
// Now open the database and add the index to it
ClicDb db(dbFilename);
BOOST_FOREACH(const ClicIndex::value_type& it, index) {
const std::string& usr = it.first;
db.addMultiple(usr, it.second);
}
return 0;
}
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 main(int argc, char *argv[])
{
auto index = clang_createIndex(0, 0);
auto options = clang_defaultEditingTranslationUnitOptions();
char const *args[] = { "-x", "c++", "-std=c++11" };
auto arg_count = sizeof( args ) / sizeof( *args );
filename = argv[1];
CXUnsavedFile *unsaved_files = NULL;
auto unsaved_file_count = 0;
tu = clang_parseTranslationUnit(index, filename.c_str(), args, arg_count,
unsaved_files, unsaved_file_count,
options );
if ( !tu ) {
std::cout << "Translation Unit Parse Failed!\n";
return -1;
}
std::stringstream ss( argv[2] );
int line, col;
ss >> line;
ss.get();
ss >> col;
std::cout << "Hello " << line << ":" << col << "\n";
auto file = clang_getFile( tu, filename.c_str() );
auto location = clang_getLocation( tu, file, line, col );
clang_visitChildren( clang_getTranslationUnitCursor( tu ), visitor,
reinterpret_cast<CXClientData>(0) );
auto cursor = clang_getCursor( tu, location );
auto refcursor = clang_getCursorReferenced( cursor );
auto rrefcursor = clang_getCursorReferenced( refcursor );
auto arf = clang_getTypeKindSpelling( clang_getCursorType( cursor ).kind );
auto foo = clang_getCanonicalCursor( cursor );
auto semparent = clang_getCursorSemanticParent( cursor );
auto lexparent = clang_getCursorLexicalParent( cursor );
std::cout << cursor << "\n";
std::cout << refcursor << "\n";
std::cout << rrefcursor << "\n";
std::cout << clang_getCString(arf) << "\n";
std::cout << foo << "\n";
std::cout << "Parent: " << semparent << "\n";
std::cout << "LexParent: " << lexparent << "\n";
//clang_visitChildren( semparent, visitor, reinterpret_cast<CXClientData>(0) );
clang_disposeString( arf );
return 0;
}
Server::Server()
: mVerbose(false), mJobId(0), mIndexerThreadPool(0), mQueryThreadPool(0), mCurrentFileId(0)
{
assert(!sInstance);
sInstance = this;
mUnloadTimer.timeout().connect(std::bind(&Server::onUnload, this));
mClearCompletionCacheTimer.timeout().connect(std::bind(&Server::clearCompletionCache, this));
mIndex = clang_createIndex(0, 1);
}
static int perform_file_scan(const char *ast_file, const char *source_file,
const char *prefix) {
CXIndex Idx;
CXTranslationUnit TU;
FILE *fp;
CXCursor prevCursor = clang_getNullCursor();
CXFile file;
unsigned line = 1, col = 1;
unsigned start_line = 1, start_col = 1;
if (!(Idx = clang_createIndex(/* excludeDeclsFromPCH */ 1,
/* displayDiagnosics=*/1))) {
fprintf(stderr, "Could not create Index\n");
return 1;
}
if (!CreateTranslationUnit(Idx, ast_file, &TU))
return 1;
if ((fp = fopen(source_file, "r")) == NULL) {
fprintf(stderr, "Could not open '%s'\n", source_file);
return 1;
}
file = clang_getFile(TU, source_file);
for (;;) {
CXCursor cursor;
int c = fgetc(fp);
if (c == '\n') {
++line;
col = 1;
} else
++col;
/* Check the cursor at this position, and dump the previous one if we have
* found something new.
*/
cursor = clang_getCursor(TU, clang_getLocation(TU, file, line, col));
if ((c == EOF || !clang_equalCursors(cursor, prevCursor)) &&
prevCursor.kind != CXCursor_InvalidFile) {
print_cursor_file_scan(prevCursor, start_line, start_col,
line, col, prefix);
start_line = line;
start_col = col;
}
if (c == EOF)
break;
prevCursor = cursor;
}
fclose(fp);
return 0;
}
CXIndex TranslationUnit::index() const
{
checkIfNull();
if (!d->index) {
const bool displayDiagnostics = verboseLibLog().isDebugEnabled();
d->index = clang_createIndex(1, displayDiagnostics);
}
return d->index;
}
static void
gb_compiler_clang_init (GbCompilerClang *clang)
{
clang->priv = G_TYPE_INSTANCE_GET_PRIVATE(clang,
GB_TYPE_COMPILER_CLANG,
GbCompilerClangPrivate);
g_object_set(clang, "name", "clang", NULL);
clang->priv->index = clang_createIndex(0, 0);
}
/* Initialize session object and launch the completion server, preparse the source file and
build the AST for furture code completion requests
*/
void startup_completionSession(int argc, char *argv[], completion_Session *session)
{
__initialize_completionSession(argc, argv, session);
/* default parameters */
session->ParseOptions = DEFAULT_PARSE_OPTIONS;
session->CompleteAtOptions = DEFAULT_COMPLETEAT_OPTIONS;
session->cx_index = clang_createIndex(0, 0);
completion_parseTranslationUnit(session);
completion_reparseTranslationUnit(session);
}
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 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
}
void ReflectionParser::Parse(void)
{
m_index = clang_createIndex( true, m_options.displayDiagnostics );
std::vector<const char *> arguments;
#if defined(SYSTEM_INCLUDE_DIRECTORY)
arguments.emplace_back( "-I" SYSTEM_INCLUDE_DIRECTORY );
#endif
for (auto &argument : m_options.arguments)
arguments.emplace_back( argument.c_str( ) );
if (m_options.displayDiagnostics)
{
for (auto *argument : arguments)
std::cout << argument << std::endl;
}
m_translationUnit = clang_createTranslationUnitFromSourceFile(
m_index,
m_options.inputSourceFile.c_str( ),
static_cast<int>( arguments.size( ) ),
arguments.data( ),
0,
nullptr
);
auto cursor = clang_getTranslationUnitCursor( m_translationUnit );
Namespace tempNamespace;
buildClasses( cursor, tempNamespace );
tempNamespace.clear( );
buildGlobals( cursor, tempNamespace );
tempNamespace.clear( );
buildGlobalFunctions( cursor, tempNamespace );
tempNamespace.clear( );
buildEnums( cursor, tempNamespace );
}
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[])
{
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 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;
}
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 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;
}
ClangDriver::ClangDriver()
: m_isBusy(false)
, m_activeEditor(NULL)
, m_position(wxNOT_FOUND)
{
m_index = clang_createIndex(0, 0);
m_pchMakerThread.Start();
#ifdef __WXMSW__
m_clangCleanerThread.Start();
#endif
EventNotifier::Get()->Connect(
wxEVT_CLANG_PCH_CACHE_ENDED, wxCommandEventHandler(ClangDriver::OnPrepareTUEnded), NULL, this);
EventNotifier::Get()->Connect(
wxEVT_CLANG_PCH_CACHE_CLEARED, wxCommandEventHandler(ClangDriver::OnCacheCleared), NULL, this);
EventNotifier::Get()->Connect(
wxEVT_CLANG_TU_CREATE_ERROR, wxCommandEventHandler(ClangDriver::OnTUCreateError), NULL, this);
EventNotifier::Get()->Connect(
wxEVT_WORKSPACE_LOADED, wxCommandEventHandler(ClangDriver::OnWorkspaceLoaded), NULL, this);
}
