virtual enum CXChildVisitResult visit(CXCursor cursor, CXCursor parent) {
CXFile file;
unsigned int line, column, offset;
clang_getInstantiationLocation(
clang_getCursorLocation(cursor),
&file, &line, &column, &offset);
CXCursorKind kind = clang_getCursorKind(cursor);
const char* cursorFilename = clang_getCString(clang_getFileName(file));
if (!clang_getFileName(file).data || strcmp(cursorFilename, translationUnitFilename) != 0) {
return CXChildVisit_Continue;
}
CXCursor refCursor = clang_getCursorReferenced(cursor);
if (!clang_equalCursors(refCursor, clang_getNullCursor())) {
CXFile refFile;
unsigned int refLine, refColumn, refOffset;
clang_getInstantiationLocation(
clang_getCursorLocation(refCursor),
&refFile, &refLine, &refColumn, &refOffset);
if (clang_getFileName(refFile).data) {
std::string referencedUsr(clang_getCString(clang_getCursorUSR(refCursor)));
if (!referencedUsr.empty()) {
std::stringstream ss;
ss << cursorFilename
<< ":" << line << ":" << column << ":" << kind;
std::string location(ss.str());
usrToReferences[referencedUsr].insert(location);
}
}
}
return CXChildVisit_Recurse;
}
CXCursor findChild(CXCursor parent, CXCursorKind kind)
{
FindChildVisitor u = { kind, String(), clang_getNullCursor() };
if (!clang_isInvalid(clang_getCursorKind(parent)))
clang_visitChildren(parent, findChildVisitor, &u);
return u.cursor;
}
CXCursor findChild(CXCursor parent, const String &name)
{
FindChildVisitor u = { CXCursor_FirstInvalid, name, clang_getNullCursor() };
if (!clang_isInvalid(clang_getCursorKind(parent)))
clang_visitChildren(parent, findChildVisitor, &u);
return u.cursor;
}
static void PrintCursor(CXCursor Cursor) {
if (clang_isInvalid(Cursor.kind)) {
CXString ks = clang_getCursorKindSpelling(Cursor.kind);
printf("Invalid Cursor => %s", clang_getCString(ks));
clang_disposeString(ks);
}
else {
CXString string, ks;
CXCursor Referenced;
unsigned line, column;
ks = clang_getCursorKindSpelling(Cursor.kind);
string = clang_getCursorSpelling(Cursor);
printf("%s=%s", clang_getCString(ks),
clang_getCString(string));
clang_disposeString(ks);
clang_disposeString(string);
Referenced = clang_getCursorReferenced(Cursor);
if (!clang_equalCursors(Referenced, clang_getNullCursor())) {
CXSourceLocation Loc = clang_getCursorLocation(Referenced);
clang_getInstantiationLocation(Loc, 0, &line, &column, 0);
printf(":%d:%d", line, column);
}
if (clang_isCursorDefinition(Cursor))
printf(" (Definition)");
}
}
CXCursor findFirstChild(CXCursor parent)
{
CXCursor ret = clang_getNullCursor();
if (!clang_isInvalid(clang_getCursorKind(parent)))
clang_visitChildren(parent, findFirstChildVisitor, &ret);
return ret;
}
static CXCursor getNthChildCursor(CXCursor cursor, int nth)
{
ChildCountVisitor visitorData(nth);
clang_visitChildren(cursor, ChildNthVisitor, &visitorData);
CXCursor childCursor = clang_getNullCursor();
if(visitorData.mCount == 0)
childCursor = visitorData.mFoundCursor;
return childCursor;
}
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;
}
SEXP R_clang_getNullCursor()
{
SEXP r_ans = R_NilValue;
CXCursor ans;
ans = clang_getNullCursor();
r_ans = R_makeCXCursor(ans) ;
return(r_ans);
}
CXCursor libclang_vim::search_kind(
const CXCursor& cursor,
const std::function<bool(const CXCursorKind&)>& predicate) {
const auto kind = clang_getCursorKind(cursor);
if (predicate(kind)) {
return cursor;
}
auto kind_visitor_data = std::make_pair(clang_getNullCursor(), predicate);
clang_visitChildren(cursor, search_kind_visitor, &kind_visitor_data);
return kind_visitor_data.first;
}
CXCursor TranslationUnit::GetCursor( int line, int column ) {
// ASSUMES A LOCK IS ALREADY HELD ON clang_access_mutex_!
if ( !clang_translation_unit_ )
return clang_getNullCursor();
CXFile file = clang_getFile( clang_translation_unit_, filename_.c_str() );
CXSourceLocation source_location = clang_getLocation(
clang_translation_unit_,
file,
line,
column );
return clang_getCursor( clang_translation_unit_, source_location );
}
std::ostream& operator<<( std::ostream &os, CXCursor cursor )
{
auto spelling = clang_getCursorKindSpelling( cursor.kind );
auto morespell = clang_getCursorSpelling( cursor );
os << clang_getCString( spelling ) << ":"
<< clang_getCString( morespell ) << " ";
clang_disposeString( spelling );
clang_disposeString( morespell );
auto refcursor = clang_getCursorReferenced( cursor );
if ( clang_equalCursors( refcursor, clang_getNullCursor() )||
clang_equalCursors( refcursor, cursor ) )
return os;
return os << " [ " << refcursor << " ] ";
}
std::shared_ptr<AST> AST::create(const Source &source, const String &sourceCode, CXTranslationUnit unit)
{
std::shared_ptr<AST> ast(new AST);
ast->mState.reset(new sel::State {true});
sel::State &state = *ast->mState;
registerClasses(state);
ast->mSourceCode = sourceCode;
state["sourceFile"] = source.sourceFile().ref();
state["sourceCode"] = sourceCode.ref();
state["write"] = [ast](const std::string &str) {
// error() << "writing" << str;
ast->mReturnValues.append(str);
};
exposeArray(state["commandLine"], source.toCommandLine(Source::Default|Source::IncludeCompiler|Source::IncludeSourceFile));
if (unit) {
UserData userData;
userData.ast = ast.get();
visitor(clang_getTranslationUnitCursor(unit), clang_getNullCursor(), &userData);
const Cursor root = userData.parents.front();
state["root"] = [root]() { return root; };
state["findByUsr"] = [ast](const std::string &usr) {
return ast->mByUsr.value(usr);
};
state["findByOffset"] = [ast](const std::string &str) {
// int offset = atoi(str.c_str());
// if (offset) {
// } else
// sscanf
// return mByUsr.value(usr);
};
const String script = Path(TO_STR(RTAGS_SOURCE_DIR) "/rtags.lua").readAll();
state(script.constData());
}
return ast;
}
Cursor::Cursor()
: cursor_(clang_getNullCursor())
{}
ChildCountVisitor(int count):
mCount(count)
{
mFoundCursor = clang_getNullCursor();
}
static void PrintCursor(CXCursor Cursor) {
if (clang_isInvalid(Cursor.kind)) {
CXString ks = clang_getCursorKindSpelling(Cursor.kind);
printf("Invalid Cursor => %s", clang_getCString(ks));
clang_disposeString(ks);
}
else {
CXString string, ks;
CXCursor Referenced;
unsigned line, column;
CXCursor SpecializationOf;
ks = clang_getCursorKindSpelling(Cursor.kind);
string = clang_getCursorSpelling(Cursor);
printf("%s=%s", clang_getCString(ks),
clang_getCString(string));
clang_disposeString(ks);
clang_disposeString(string);
Referenced = clang_getCursorReferenced(Cursor);
if (!clang_equalCursors(Referenced, clang_getNullCursor())) {
CXSourceLocation Loc = clang_getCursorLocation(Referenced);
clang_getInstantiationLocation(Loc, 0, &line, &column, 0);
printf(":%d:%d", line, column);
}
if (clang_isCursorDefinition(Cursor))
printf(" (Definition)");
switch (clang_getCursorAvailability(Cursor)) {
case CXAvailability_Available:
break;
case CXAvailability_Deprecated:
printf(" (deprecated)");
break;
case CXAvailability_NotAvailable:
printf(" (unavailable)");
break;
}
if (Cursor.kind == CXCursor_IBOutletCollectionAttr) {
CXType T =
clang_getCanonicalType(clang_getIBOutletCollectionType(Cursor));
CXString S = clang_getTypeKindSpelling(T.kind);
printf(" [IBOutletCollection=%s]", clang_getCString(S));
clang_disposeString(S);
}
if (Cursor.kind == CXCursor_CXXBaseSpecifier) {
enum CX_CXXAccessSpecifier access = clang_getCXXAccessSpecifier(Cursor);
unsigned isVirtual = clang_isVirtualBase(Cursor);
const char *accessStr = 0;
switch (access) {
case CX_CXXInvalidAccessSpecifier:
accessStr = "invalid"; break;
case CX_CXXPublic:
accessStr = "public"; break;
case CX_CXXProtected:
accessStr = "protected"; break;
case CX_CXXPrivate:
accessStr = "private"; break;
}
printf(" [access=%s isVirtual=%s]", accessStr,
isVirtual ? "true" : "false");
}
SpecializationOf = clang_getSpecializedCursorTemplate(Cursor);
if (!clang_equalCursors(SpecializationOf, clang_getNullCursor())) {
CXSourceLocation Loc = clang_getCursorLocation(SpecializationOf);
CXString Name = clang_getCursorSpelling(SpecializationOf);
clang_getInstantiationLocation(Loc, 0, &line, &column, 0);
printf(" [Specialization of %s:%d:%d]",
clang_getCString(Name), line, column);
clang_disposeString(Name);
}
}
}
Cursor::Cursor() {
cursor_ = clang_getNullCursor();
}
cursor cursor::null()
{
return { clang_getNullCursor() };
}
/** Constructor
*
* \param parent Parent node
*/
explicit Clang_AST_CXTreeNode(Clang_AST_CXTreeNode* parent = nullptr)
: m_parentNode(parent), m_astObject(nullptr), m_visibility(VISIBILITY_NONE), m_fullName("")
{
m_canonicalCursor = clang_getNullCursor();
}
struct Dep : public DependencyNode
{
Dep(uint32_t f)
: DependencyNode(f)
{}
Hash<uint32_t, Map<Location, Location> > references;
};
DumpThread::DumpThread(const std::shared_ptr<QueryMessage> &queryMessage, const Source &source, const std::shared_ptr<Connection> &conn)
: Thread(), mQueryFlags(queryMessage->flags()), mSource(source), mConnection(conn), mIndentLevel(0), mAborted(false)
{
setAutoDelete(true);
}
static const CXSourceLocation nullLocation = clang_getNullLocation();
static const CXCursor nullCursor = clang_getNullCursor();
CXChildVisitResult DumpThread::visitor(CXCursor cursor, CXCursor, CXClientData userData)
{
DumpThread *that = reinterpret_cast<DumpThread*>(userData);
assert(that);
return that->visit(cursor);
}
CXChildVisitResult DumpThread::visit(const CXCursor &cursor)
{
if (isAborted())
return CXChildVisit_Break;
const Location location = createLocation(cursor);
if (!location.isNull()) {
if (mQueryFlags & QueryMessage::DumpCheckIncludes) {
Cursor::Cursor()
: cxCursor(clang_getNullCursor())
{
}