SEXP R_clang_getSpecializedCursorTemplate(SEXP r_C)
{
SEXP r_ans = R_NilValue;
CXCursor C = * GET_REF(r_C, CXCursor);
CXCursor ans;
ans = clang_getSpecializedCursorTemplate(C);
r_ans = R_makeCXCursor(ans) ;
return(r_ans);
}
void ClangParser::linkIdentifier(CodeOutputInterface &ol,FileDef *fd,
uint &line,uint &column,const char *text,int tokenIndex)
{
CXCursor c = p->cursors[tokenIndex];
CXCursor r = clang_getCursorReferenced(c);
if (!clang_equalCursors(r, c))
{
c=r; // link to referenced location
}
CXCursor t = clang_getSpecializedCursorTemplate(c);
if (!clang_Cursor_isNull(t) && !clang_equalCursors(t,c))
{
c=t; // link to template
}
CXString usr = clang_getCursorUSR(c);
const char *usrStr = clang_getCString(usr);
Definition *d = usrStr ? Doxygen::clangUsrMap->find(usrStr) : 0;
//CXCursorKind kind = clang_getCursorKind(c);
//if (d==0)
//{
// printf("didn't find definition for '%s' usr='******' kind=%d\n",
// text,usrStr,kind);
//}
//else
//{
// printf("found definition for '%s' usr='******' name='%s'\n",
// text,usrStr,d->name().data());
//}
if (d && d->isLinkable())
{
if (g_insideBody &&
g_currentMemberDef && d->definitionType()==Definition::TypeMember &&
(g_currentMemberDef!=d || g_currentLine<line)) // avoid self-reference
{
addDocCrossReference(g_currentMemberDef,(MemberDef*)d);
}
writeMultiLineCodeLink(ol,fd,line,column,d,text);
}
else
{
codifyLines(ol,fd,text,line,column);
}
clang_disposeString(usr);
}
void ClangParser::linkIdentifier(CodeOutputInterface &ol, QSharedPointer<FileDef> fd,
uint &line, uint &column, const QString &text, int tokenIndex)
{
CXCursor c = p->cursors[tokenIndex];
CXCursor r = clang_getCursorReferenced(c);
if (! clang_equalCursors(r, c)) {
// link to referenced location
c = r;
}
CXCursor t = clang_getSpecializedCursorTemplate(c);
if (! clang_Cursor_isNull(t) && !clang_equalCursors(t, c)) {
// link to template
c = t;
}
CXString usr = clang_getCursorUSR(c);
const char *usrStr = clang_getCString(usr);
QSharedPointer<Definition> d;
if (usrStr) {
d = Doxy_Globals::clangUsrMap.value(usrStr);
}
if (d && d->isLinkable()) {
if (g_insideBody && g_currentMemberDef && d->definitionType() == Definition::TypeMember &&
(g_currentMemberDef != d || g_currentLine < line)) {
// avoid self-reference
addDocCrossReference(g_currentMemberDef, d.dynamicCast<MemberDef>());
}
writeMultiLineCodeLink(ol, fd, line, column, d, text);
} else {
codifyLines(ol, fd, text, line, column, "");
}
clang_disposeString(usr);
}
CXChildVisitResult DumpThread::visit(const CXCursor &cursor)
{
if (isAborted())
return CXChildVisit_Break;
const Location location = createLocation(cursor);
if (!location.isNull()) {
if (mQueryFlags & QueryMessage::DumpCheckIncludes) {
checkIncludes(location, cursor);
return CXChildVisit_Recurse;
} else {
Flags<Location::ToStringFlag> locationFlags;
if (mQueryFlags & QueryMessage::NoColor)
locationFlags |= Location::NoColor;
CXSourceRange range = clang_getCursorExtent(cursor);
CXSourceLocation rangeEnd = clang_getRangeEnd(range);
unsigned int endLine, endColumn;
clang_getPresumedLocation(rangeEnd, 0, &endLine, &endColumn);
if (!(mQueryFlags & QueryMessage::DumpIncludeHeaders) && location.fileId() != mSource.fileId) {
return CXChildVisit_Continue;
}
String message;
message.reserve(256);
if (!(mQueryFlags & QueryMessage::NoContext)) {
message = location.context(locationFlags);
}
if (endLine == location.line()) {
message += String::format<32>(" // %d-%d, %d: ", location.column(), endColumn, mIndentLevel);
} else {
message += String::format<32>(" // %d-%d:%d, %d: ", location.column(), endLine, endColumn, mIndentLevel);
}
message += RTags::cursorToString(cursor, RTags::AllCursorToStringFlags);
message.append(" " + RTags::typeName(cursor));;
if (clang_getCursorKind(cursor) == CXCursor_VarDecl) {
const std::shared_ptr<RTags::Auto> autoResolved = RTags::resolveAuto(cursor);
if (autoResolved && !clang_equalCursors(autoResolved->cursor, nullCursor)) {
message += "auto resolves to " + RTags::cursorToString(autoResolved->cursor, RTags::AllCursorToStringFlags);
}
}
CXCursor ref = clang_getCursorReferenced(cursor);
if (clang_equalCursors(ref, cursor)) {
message.append("refs self");
} else if (!clang_equalCursors(ref, nullCursor)) {
message.append("refs ");
message.append(RTags::cursorToString(ref, RTags::AllCursorToStringFlags));
}
CXCursor canonical = clang_getCanonicalCursor(cursor);
if (!clang_equalCursors(canonical, cursor) && !clang_equalCursors(canonical, nullCursor)) {
message.append("canonical ");
message.append(RTags::cursorToString(canonical, RTags::AllCursorToStringFlags));
}
CXCursor specialized = clang_getSpecializedCursorTemplate(cursor);
if (!clang_equalCursors(specialized, cursor) && !clang_equalCursors(specialized, nullCursor)) {
message.append("specialized ");
message.append(RTags::cursorToString(specialized, RTags::AllCursorToStringFlags));
}
writeToConnetion(message);
}
}
++mIndentLevel;
clang_visitChildren(cursor, DumpThread::visitor, this);
if (isAborted())
return CXChildVisit_Break;
--mIndentLevel;
return CXChildVisit_Continue;
}
cursor cursor::getSpecializedTemplate()
{
return { clang_getSpecializedCursorTemplate(cur) };
}
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);
}
}
}