head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.12 netbsd-11-0-RC3:1.1.1.12 netbsd-11-0-RC2:1.1.1.12 netbsd-11-0-RC1:1.1.1.12 perseant-exfatfs-base-20250801:1.1.1.12 netbsd-11:1.1.1.12.0.10 netbsd-11-base:1.1.1.12 netbsd-10-1-RELEASE:1.1.1.12 perseant-exfatfs-base-20240630:1.1.1.12 perseant-exfatfs:1.1.1.12.0.8 perseant-exfatfs-base:1.1.1.12 netbsd-8-3-RELEASE:1.1.1.9 netbsd-9-4-RELEASE:1.1.1.11 netbsd-10-0-RELEASE:1.1.1.12 netbsd-10-0-RC6:1.1.1.12 netbsd-10-0-RC5:1.1.1.12 netbsd-10-0-RC4:1.1.1.12 netbsd-10-0-RC3:1.1.1.12 netbsd-10-0-RC2:1.1.1.12 netbsd-10-0-RC1:1.1.1.12 netbsd-10:1.1.1.12.0.6 netbsd-10-base:1.1.1.12 netbsd-9-3-RELEASE:1.1.1.11 cjep_sun2x:1.1.1.12.0.4 cjep_sun2x-base:1.1.1.12 cjep_staticlib_x-base1:1.1.1.12 netbsd-9-2-RELEASE:1.1.1.11 cjep_staticlib_x:1.1.1.12.0.2 cjep_staticlib_x-base:1.1.1.12 netbsd-9-1-RELEASE:1.1.1.11 phil-wifi-20200421:1.1.1.12 phil-wifi-20200411:1.1.1.12 phil-wifi-20200406:1.1.1.12 netbsd-8-2-RELEASE:1.1.1.9 netbsd-9-0-RELEASE:1.1.1.11 netbsd-9-0-RC2:1.1.1.11 netbsd-9-0-RC1:1.1.1.11 netbsd-9:1.1.1.11.0.2 netbsd-9-base:1.1.1.11 phil-wifi-20190609:1.1.1.11 netbsd-8-1-RELEASE:1.1.1.9 netbsd-8-1-RC1:1.1.1.9 pgoyette-compat-merge-20190127:1.1.1.10.2.1 pgoyette-compat-20190127:1.1.1.11 pgoyette-compat-20190118:1.1.1.11 pgoyette-compat-1226:1.1.1.11 pgoyette-compat-1126:1.1.1.11 pgoyette-compat-1020:1.1.1.11 pgoyette-compat-0930:1.1.1.11 pgoyette-compat-0906:1.1.1.11 netbsd-7-2-RELEASE:1.1.1.5.2.1 pgoyette-compat-0728:1.1.1.11 clang-337282:1.1.1.11 netbsd-8-0-RELEASE:1.1.1.9 phil-wifi:1.1.1.10.0.4 phil-wifi-base:1.1.1.10 pgoyette-compat-0625:1.1.1.10 netbsd-8-0-RC2:1.1.1.9 pgoyette-compat-0521:1.1.1.10 pgoyette-compat-0502:1.1.1.10 pgoyette-compat-0422:1.1.1.10 netbsd-8-0-RC1:1.1.1.9 pgoyette-compat-0415:1.1.1.10 pgoyette-compat-0407:1.1.1.10 pgoyette-compat-0330:1.1.1.10 pgoyette-compat-0322:1.1.1.10 pgoyette-compat-0315:1.1.1.10 netbsd-7-1-2-RELEASE:1.1.1.5.2.1 pgoyette-compat:1.1.1.10.0.2 pgoyette-compat-base:1.1.1.10 netbsd-7-1-1-RELEASE:1.1.1.5.2.1 clang-319952:1.1.1.10 matt-nb8-mediatek:1.1.1.9.0.8 matt-nb8-mediatek-base:1.1.1.9 clang-309604:1.1.1.10 perseant-stdc-iso10646:1.1.1.9.0.6 perseant-stdc-iso10646-base:1.1.1.9 netbsd-8:1.1.1.9.0.4 netbsd-8-base:1.1.1.9 prg-localcount2-base3:1.1.1.9 prg-localcount2-base2:1.1.1.9 prg-localcount2-base1:1.1.1.9 prg-localcount2:1.1.1.9.0.2 prg-localcount2-base:1.1.1.9 pgoyette-localcount-20170426:1.1.1.9 bouyer-socketcan-base1:1.1.1.9 pgoyette-localcount-20170320:1.1.1.9 netbsd-7-1:1.1.1.5.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.5.2.1 netbsd-7-1-RC2:1.1.1.5.2.1 clang-294123:1.1.1.9 netbsd-7-nhusb-base-20170116:1.1.1.5.2.1 bouyer-socketcan:1.1.1.8.0.2 bouyer-socketcan-base:1.1.1.8 clang-291444:1.1.1.8 pgoyette-localcount-20170107:1.1.1.7 netbsd-7-1-RC1:1.1.1.5.2.1 pgoyette-localcount-20161104:1.1.1.7 netbsd-7-0-2-RELEASE:1.1.1.5.2.1 localcount-20160914:1.1.1.7 netbsd-7-nhusb:1.1.1.5.2.1.0.4 netbsd-7-nhusb-base:1.1.1.5.2.1 clang-280599:1.1.1.7 pgoyette-localcount-20160806:1.1.1.7 pgoyette-localcount-20160726:1.1.1.7 pgoyette-localcount:1.1.1.7.0.2 pgoyette-localcount-base:1.1.1.7 netbsd-7-0-1-RELEASE:1.1.1.5.2.1 clang-261930:1.1.1.7 netbsd-7-0:1.1.1.5.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.5.2.1 netbsd-7-0-RC3:1.1.1.5.2.1 netbsd-7-0-RC2:1.1.1.5.2.1 netbsd-7-0-RC1:1.1.1.5.2.1 clang-237755:1.1.1.6 clang-232565:1.1.1.6 clang-227398:1.1.1.6 tls-maxphys-base:1.1.1.5 tls-maxphys:1.1.1.5.0.4 netbsd-7:1.1.1.5.0.2 netbsd-7-base:1.1.1.5 clang-215315:1.1.1.5 clang-209886:1.1.1.4 yamt-pagecache:1.1.1.3.0.4 yamt-pagecache-base9:1.1.1.3 tls-earlyentropy:1.1.1.3.0.2 tls-earlyentropy-base:1.1.1.4 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.3 riastradh-drm2-base3:1.1.1.3 clang-202566:1.1.1.3 clang-201163:1.1.1.2 clang-199312:1.1.1.2 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.48; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.48; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.37.54; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.03.04.19.53.18; author joerg; state Exp; branches 1.1.1.3.2.1 1.1.1.3.4.1; next 1.1.1.4; commitid 29z1hJonZISIXprx; 1.1.1.4 date 2014.05.30.18.14.49; author joerg; state Exp; branches; next 1.1.1.5; commitid 8q0kdlBlCn09GACx; 1.1.1.5 date 2014.08.10.17.08.24; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid N85tXAN6Ex9VZPLx; 1.1.1.6 date 2015.01.29.19.57.27; author joerg; state Exp; branches; next 1.1.1.7; commitid mlISSizlPKvepX7y; 1.1.1.7 date 2016.02.27.22.10.58; author joerg; state Exp; branches 1.1.1.7.2.1; next 1.1.1.8; commitid tIimz3oDlh1NpBWy; 1.1.1.8 date 2017.01.11.10.32.19; author joerg; state Exp; branches 1.1.1.8.2.1; next 1.1.1.9; commitid CNnUNfII1jgNmxBz; 1.1.1.9 date 2017.02.09.17.36.39; author joerg; state Exp; branches; next 1.1.1.10; commitid UxB8JMFWM7xyMiFz; 1.1.1.10 date 2017.08.01.19.37.51; author joerg; state Exp; branches 1.1.1.10.2.1 1.1.1.10.4.1; next 1.1.1.11; commitid pMuDy65V0VicSx1A; 1.1.1.11 date 2018.07.17.18.32.07; author joerg; state Exp; branches; next 1.1.1.12; commitid wDzL46ALjrCZgwKA; 1.1.1.12 date 2019.11.13.22.23.06; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.3.2.1 date 2014.08.10.07.08.25; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.3.4.1 date 2014.03.04.19.53.18; author yamt; state dead; branches; next 1.1.1.3.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.3.4.2 date 2014.05.22.16.19.47; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.2.1 date 2015.06.04.20.04.46; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.5.4.1 date 2014.08.10.17.08.24; author tls; state dead; branches; next 1.1.1.5.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.5.4.2 date 2014.08.19.23.49.27; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.2.1 date 2017.03.20.06.53.37; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.8.2.1 date 2017.04.21.16.51.44; author bouyer; state Exp; branches; next ; commitid dUG7nkTKALCadqOz; 1.1.1.10.2.1 date 2018.07.28.04.34.16; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.10.4.1 date 2019.06.10.21.46.43; author christos; state Exp; branches; next 1.1.1.10.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.10.4.2 date 2020.04.13.07.50.33; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===- CXCursor.cpp - Routines for manipulating CXCursors -----------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines routines for manipulating CXCursors. It should be the // only file that has internal knowledge of the encoding of the data in // CXCursor. // //===----------------------------------------------------------------------===// #include "CXTranslationUnit.h" #include "CXCursor.h" #include "CXString.h" #include "CXType.h" #include "clang-c/Index.h" #include "clang/AST/Attr.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/ExprObjC.h" #include "clang/Frontend/ASTUnit.h" #include "llvm/Support/ErrorHandling.h" using namespace clang; using namespace cxcursor; CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K, CXTranslationUnit TU) { assert(K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid); CXCursor C = { K, 0, { 0, 0, TU } }; return C; } static CXCursorKind GetCursorKind(const Attr *A) { assert(A && "Invalid arguments!"); switch (A->getKind()) { default: break; case attr::IBAction: return CXCursor_IBActionAttr; case attr::IBOutlet: return CXCursor_IBOutletAttr; case attr::IBOutletCollection: return CXCursor_IBOutletCollectionAttr; case attr::Final: return CXCursor_CXXFinalAttr; case attr::Override: return CXCursor_CXXOverrideAttr; case attr::Annotate: return CXCursor_AnnotateAttr; case attr::AsmLabel: return CXCursor_AsmLabelAttr; case attr::Packed: return CXCursor_PackedAttr; } return CXCursor_UnexposedAttr; } CXCursor cxcursor::MakeCXCursor(const Attr *A, const Decl *Parent, CXTranslationUnit TU) { assert(A && Parent && TU && "Invalid arguments!"); CXCursor C = { GetCursorKind(A), 0, { Parent, A, TU } }; return C; } CXCursor cxcursor::MakeCXCursor(const Decl *D, CXTranslationUnit TU, SourceRange RegionOfInterest, bool FirstInDeclGroup) { assert(D && TU && "Invalid arguments!"); CXCursorKind K = getCursorKindForDecl(D); if (K == CXCursor_ObjCClassMethodDecl || K == CXCursor_ObjCInstanceMethodDecl) { int SelectorIdIndex = -1; // Check if cursor points to a selector id. if (RegionOfInterest.isValid() && RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) { SmallVector SelLocs; cast(D)->getSelectorLocs(SelLocs); SmallVectorImpl::iterator I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin()); if (I != SelLocs.end()) SelectorIdIndex = I - SelLocs.begin(); } CXCursor C = { K, SelectorIdIndex, { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }}; return C; } CXCursor C = { K, 0, { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }}; return C; } CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent, CXTranslationUnit TU, SourceRange RegionOfInterest) { assert(S && TU && "Invalid arguments!"); CXCursorKind K = CXCursor_NotImplemented; switch (S->getStmtClass()) { case Stmt::NoStmtClass: break; case Stmt::CaseStmtClass: K = CXCursor_CaseStmt; break; case Stmt::DefaultStmtClass: K = CXCursor_DefaultStmt; break; case Stmt::IfStmtClass: K = CXCursor_IfStmt; break; case Stmt::SwitchStmtClass: K = CXCursor_SwitchStmt; break; case Stmt::WhileStmtClass: K = CXCursor_WhileStmt; break; case Stmt::DoStmtClass: K = CXCursor_DoStmt; break; case Stmt::ForStmtClass: K = CXCursor_ForStmt; break; case Stmt::GotoStmtClass: K = CXCursor_GotoStmt; break; case Stmt::IndirectGotoStmtClass: K = CXCursor_IndirectGotoStmt; break; case Stmt::ContinueStmtClass: K = CXCursor_ContinueStmt; break; case Stmt::BreakStmtClass: K = CXCursor_BreakStmt; break; case Stmt::ReturnStmtClass: K = CXCursor_ReturnStmt; break; case Stmt::GCCAsmStmtClass: K = CXCursor_GCCAsmStmt; break; case Stmt::MSAsmStmtClass: K = CXCursor_MSAsmStmt; break; case Stmt::ObjCAtTryStmtClass: K = CXCursor_ObjCAtTryStmt; break; case Stmt::ObjCAtCatchStmtClass: K = CXCursor_ObjCAtCatchStmt; break; case Stmt::ObjCAtFinallyStmtClass: K = CXCursor_ObjCAtFinallyStmt; break; case Stmt::ObjCAtThrowStmtClass: K = CXCursor_ObjCAtThrowStmt; break; case Stmt::ObjCAtSynchronizedStmtClass: K = CXCursor_ObjCAtSynchronizedStmt; break; case Stmt::ObjCAutoreleasePoolStmtClass: K = CXCursor_ObjCAutoreleasePoolStmt; break; case Stmt::ObjCForCollectionStmtClass: K = CXCursor_ObjCForCollectionStmt; break; case Stmt::CXXCatchStmtClass: K = CXCursor_CXXCatchStmt; break; case Stmt::CXXTryStmtClass: K = CXCursor_CXXTryStmt; break; case Stmt::CXXForRangeStmtClass: K = CXCursor_CXXForRangeStmt; break; case Stmt::SEHTryStmtClass: K = CXCursor_SEHTryStmt; break; case Stmt::SEHExceptStmtClass: K = CXCursor_SEHExceptStmt; break; case Stmt::SEHFinallyStmtClass: K = CXCursor_SEHFinallyStmt; break; case Stmt::ArrayTypeTraitExprClass: case Stmt::AsTypeExprClass: case Stmt::AtomicExprClass: case Stmt::BinaryConditionalOperatorClass: case Stmt::BinaryTypeTraitExprClass: case Stmt::TypeTraitExprClass: case Stmt::CXXBindTemporaryExprClass: case Stmt::CXXDefaultArgExprClass: case Stmt::CXXDefaultInitExprClass: case Stmt::CXXStdInitializerListExprClass: case Stmt::CXXScalarValueInitExprClass: case Stmt::CXXUuidofExprClass: case Stmt::ChooseExprClass: case Stmt::DesignatedInitExprClass: case Stmt::ExprWithCleanupsClass: case Stmt::ExpressionTraitExprClass: case Stmt::ExtVectorElementExprClass: case Stmt::ImplicitCastExprClass: case Stmt::ImplicitValueInitExprClass: case Stmt::MaterializeTemporaryExprClass: case Stmt::ObjCIndirectCopyRestoreExprClass: case Stmt::OffsetOfExprClass: case Stmt::ParenListExprClass: case Stmt::PredefinedExprClass: case Stmt::ShuffleVectorExprClass: case Stmt::ConvertVectorExprClass: case Stmt::UnaryExprOrTypeTraitExprClass: case Stmt::UnaryTypeTraitExprClass: case Stmt::VAArgExprClass: case Stmt::ObjCArrayLiteralClass: case Stmt::ObjCDictionaryLiteralClass: case Stmt::ObjCBoxedExprClass: case Stmt::ObjCSubscriptRefExprClass: K = CXCursor_UnexposedExpr; break; case Stmt::OpaqueValueExprClass: if (Expr *Src = cast(S)->getSourceExpr()) return MakeCXCursor(Src, Parent, TU, RegionOfInterest); K = CXCursor_UnexposedExpr; break; case Stmt::PseudoObjectExprClass: return MakeCXCursor(cast(S)->getSyntacticForm(), Parent, TU, RegionOfInterest); case Stmt::CompoundStmtClass: K = CXCursor_CompoundStmt; break; case Stmt::NullStmtClass: K = CXCursor_NullStmt; break; case Stmt::LabelStmtClass: K = CXCursor_LabelStmt; break; case Stmt::AttributedStmtClass: K = CXCursor_UnexposedStmt; break; case Stmt::DeclStmtClass: K = CXCursor_DeclStmt; break; case Stmt::CapturedStmtClass: K = CXCursor_UnexposedStmt; break; case Stmt::IntegerLiteralClass: K = CXCursor_IntegerLiteral; break; case Stmt::FloatingLiteralClass: K = CXCursor_FloatingLiteral; break; case Stmt::ImaginaryLiteralClass: K = CXCursor_ImaginaryLiteral; break; case Stmt::StringLiteralClass: K = CXCursor_StringLiteral; break; case Stmt::CharacterLiteralClass: K = CXCursor_CharacterLiteral; break; case Stmt::ParenExprClass: K = CXCursor_ParenExpr; break; case Stmt::UnaryOperatorClass: K = CXCursor_UnaryOperator; break; case Stmt::CXXNoexceptExprClass: K = CXCursor_UnaryExpr; break; case Stmt::ArraySubscriptExprClass: K = CXCursor_ArraySubscriptExpr; break; case Stmt::BinaryOperatorClass: K = CXCursor_BinaryOperator; break; case Stmt::CompoundAssignOperatorClass: K = CXCursor_CompoundAssignOperator; break; case Stmt::ConditionalOperatorClass: K = CXCursor_ConditionalOperator; break; case Stmt::CStyleCastExprClass: K = CXCursor_CStyleCastExpr; break; case Stmt::CompoundLiteralExprClass: K = CXCursor_CompoundLiteralExpr; break; case Stmt::InitListExprClass: K = CXCursor_InitListExpr; break; case Stmt::AddrLabelExprClass: K = CXCursor_AddrLabelExpr; break; case Stmt::StmtExprClass: K = CXCursor_StmtExpr; break; case Stmt::GenericSelectionExprClass: K = CXCursor_GenericSelectionExpr; break; case Stmt::GNUNullExprClass: K = CXCursor_GNUNullExpr; break; case Stmt::CXXStaticCastExprClass: K = CXCursor_CXXStaticCastExpr; break; case Stmt::CXXDynamicCastExprClass: K = CXCursor_CXXDynamicCastExpr; break; case Stmt::CXXReinterpretCastExprClass: K = CXCursor_CXXReinterpretCastExpr; break; case Stmt::CXXConstCastExprClass: K = CXCursor_CXXConstCastExpr; break; case Stmt::CXXFunctionalCastExprClass: K = CXCursor_CXXFunctionalCastExpr; break; case Stmt::CXXTypeidExprClass: K = CXCursor_CXXTypeidExpr; break; case Stmt::CXXBoolLiteralExprClass: K = CXCursor_CXXBoolLiteralExpr; break; case Stmt::CXXNullPtrLiteralExprClass: K = CXCursor_CXXNullPtrLiteralExpr; break; case Stmt::CXXThisExprClass: K = CXCursor_CXXThisExpr; break; case Stmt::CXXThrowExprClass: K = CXCursor_CXXThrowExpr; break; case Stmt::CXXNewExprClass: K = CXCursor_CXXNewExpr; break; case Stmt::CXXDeleteExprClass: K = CXCursor_CXXDeleteExpr; break; case Stmt::ObjCStringLiteralClass: K = CXCursor_ObjCStringLiteral; break; case Stmt::ObjCEncodeExprClass: K = CXCursor_ObjCEncodeExpr; break; case Stmt::ObjCSelectorExprClass: K = CXCursor_ObjCSelectorExpr; break; case Stmt::ObjCProtocolExprClass: K = CXCursor_ObjCProtocolExpr; break; case Stmt::ObjCBoolLiteralExprClass: K = CXCursor_ObjCBoolLiteralExpr; break; case Stmt::ObjCBridgedCastExprClass: K = CXCursor_ObjCBridgedCastExpr; break; case Stmt::BlockExprClass: K = CXCursor_BlockExpr; break; case Stmt::PackExpansionExprClass: K = CXCursor_PackExpansionExpr; break; case Stmt::SizeOfPackExprClass: K = CXCursor_SizeOfPackExpr; break; case Stmt::DeclRefExprClass: if (const ImplicitParamDecl *IPD = dyn_cast_or_null(cast(S)->getDecl())) { if (const ObjCMethodDecl *MD = dyn_cast(IPD->getDeclContext())) { if (MD->getSelfDecl() == IPD) { K = CXCursor_ObjCSelfExpr; break; } } } K = CXCursor_DeclRefExpr; break; case Stmt::DependentScopeDeclRefExprClass: case Stmt::SubstNonTypeTemplateParmExprClass: case Stmt::SubstNonTypeTemplateParmPackExprClass: case Stmt::FunctionParmPackExprClass: case Stmt::UnresolvedLookupExprClass: K = CXCursor_DeclRefExpr; break; case Stmt::CXXDependentScopeMemberExprClass: case Stmt::CXXPseudoDestructorExprClass: case Stmt::MemberExprClass: case Stmt::MSPropertyRefExprClass: case Stmt::ObjCIsaExprClass: case Stmt::ObjCIvarRefExprClass: case Stmt::ObjCPropertyRefExprClass: case Stmt::UnresolvedMemberExprClass: K = CXCursor_MemberRefExpr; break; case Stmt::CallExprClass: case Stmt::CXXOperatorCallExprClass: case Stmt::CXXMemberCallExprClass: case Stmt::CUDAKernelCallExprClass: case Stmt::CXXConstructExprClass: case Stmt::CXXTemporaryObjectExprClass: case Stmt::CXXUnresolvedConstructExprClass: case Stmt::UserDefinedLiteralClass: K = CXCursor_CallExpr; break; case Stmt::LambdaExprClass: K = CXCursor_LambdaExpr; break; case Stmt::ObjCMessageExprClass: { K = CXCursor_ObjCMessageExpr; int SelectorIdIndex = -1; // Check if cursor points to a selector id. if (RegionOfInterest.isValid() && RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) { SmallVector SelLocs; cast(S)->getSelectorLocs(SelLocs); SmallVectorImpl::iterator I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin()); if (I != SelLocs.end()) SelectorIdIndex = I - SelLocs.begin(); } CXCursor C = { K, 0, { Parent, S, TU } }; return getSelectorIdentifierCursor(SelectorIdIndex, C); } case Stmt::MSDependentExistsStmtClass: K = CXCursor_UnexposedStmt; break; case Stmt::OMPParallelDirectiveClass: K = CXCursor_OMPParallelDirective; break; } CXCursor C = { K, 0, { Parent, S, TU } }; return C; } CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super, SourceLocation Loc, CXTranslationUnit TU) { assert(Super && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_ObjCSuperClassRef, 0, { Super, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorObjCSuperClassRef(CXCursor C) { assert(C.kind == CXCursor_ObjCSuperClassRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorObjCProtocolRef(const ObjCProtocolDecl *Proto, SourceLocation Loc, CXTranslationUnit TU) { assert(Proto && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_ObjCProtocolRef, 0, { Proto, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorObjCProtocolRef(CXCursor C) { assert(C.kind == CXCursor_ObjCProtocolRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorObjCClassRef(const ObjCInterfaceDecl *Class, SourceLocation Loc, CXTranslationUnit TU) { // 'Class' can be null for invalid code. if (!Class) return MakeCXCursorInvalid(CXCursor_InvalidCode); assert(TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_ObjCClassRef, 0, { Class, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorObjCClassRef(CXCursor C) { assert(C.kind == CXCursor_ObjCClassRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorTypeRef(const TypeDecl *Type, SourceLocation Loc, CXTranslationUnit TU) { assert(Type && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_TypeRef, 0, { Type, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorTypeRef(CXCursor C) { assert(C.kind == CXCursor_TypeRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorTemplateRef(const TemplateDecl *Template, SourceLocation Loc, CXTranslationUnit TU) { assert(Template && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_TemplateRef, 0, { Template, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorTemplateRef(CXCursor C) { assert(C.kind == CXCursor_TemplateRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorNamespaceRef(const NamedDecl *NS, SourceLocation Loc, CXTranslationUnit TU) { assert(NS && (isa(NS) || isa(NS)) && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_NamespaceRef, 0, { NS, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorNamespaceRef(CXCursor C) { assert(C.kind == CXCursor_NamespaceRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorVariableRef(const VarDecl *Var, SourceLocation Loc, CXTranslationUnit TU) { assert(Var && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_VariableRef, 0, { Var, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorVariableRef(CXCursor C) { assert(C.kind == CXCursor_VariableRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorMemberRef(const FieldDecl *Field, SourceLocation Loc, CXTranslationUnit TU) { assert(Field && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_MemberRef, 0, { Field, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorMemberRef(CXCursor C) { assert(C.kind == CXCursor_MemberRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorCXXBaseSpecifier(const CXXBaseSpecifier *B, CXTranslationUnit TU){ CXCursor C = { CXCursor_CXXBaseSpecifier, 0, { B, 0, TU } }; return C; } const CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) { assert(C.kind == CXCursor_CXXBaseSpecifier); return static_cast(C.data[0]); } CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range, CXTranslationUnit TU) { CXCursor C = { CXCursor_PreprocessingDirective, 0, { Range.getBegin().getPtrEncoding(), Range.getEnd().getPtrEncoding(), TU } }; return C; } SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) { assert(C.kind == CXCursor_PreprocessingDirective); SourceRange Range(SourceLocation::getFromPtrEncoding(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); ASTUnit *TU = getCursorASTUnit(C); return TU->mapRangeFromPreamble(Range); } CXCursor cxcursor::MakeMacroDefinitionCursor(const MacroDefinition *MI, CXTranslationUnit TU) { CXCursor C = { CXCursor_MacroDefinition, 0, { MI, 0, TU } }; return C; } const MacroDefinition *cxcursor::getCursorMacroDefinition(CXCursor C) { assert(C.kind == CXCursor_MacroDefinition); return static_cast(C.data[0]); } CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI, CXTranslationUnit TU) { CXCursor C = { CXCursor_MacroExpansion, 0, { MI, 0, TU } }; return C; } CXCursor cxcursor::MakeMacroExpansionCursor(MacroDefinition *MI, SourceLocation Loc, CXTranslationUnit TU) { assert(Loc.isValid()); CXCursor C = { CXCursor_MacroExpansion, 0, { MI, Loc.getPtrEncoding(), TU } }; return C; } const IdentifierInfo *cxcursor::MacroExpansionCursor::getName() const { if (isPseudo()) return getAsMacroDefinition()->getName(); return getAsMacroExpansion()->getName(); } const MacroDefinition *cxcursor::MacroExpansionCursor::getDefinition() const { if (isPseudo()) return getAsMacroDefinition(); return getAsMacroExpansion()->getDefinition(); } SourceRange cxcursor::MacroExpansionCursor::getSourceRange() const { if (isPseudo()) return getPseudoLoc(); return getAsMacroExpansion()->getSourceRange(); } CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID, CXTranslationUnit TU) { CXCursor C = { CXCursor_InclusionDirective, 0, { ID, 0, TU } }; return C; } const InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) { assert(C.kind == CXCursor_InclusionDirective); return static_cast(C.data[0]); } CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc, CXTranslationUnit TU) { assert(Label && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_LabelRef, 0, { Label, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorLabelRef(CXCursor C) { assert(C.kind == CXCursor_LabelRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorOverloadedDeclRef(const OverloadExpr *E, CXTranslationUnit TU) { assert(E && TU && "Invalid arguments!"); OverloadedDeclRefStorage Storage(E); void *RawLoc = E->getNameLoc().getPtrEncoding(); CXCursor C = { CXCursor_OverloadedDeclRef, 0, { Storage.getOpaqueValue(), RawLoc, TU } }; return C; } CXCursor cxcursor::MakeCursorOverloadedDeclRef(const Decl *D, SourceLocation Loc, CXTranslationUnit TU) { assert(D && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); OverloadedDeclRefStorage Storage(D); CXCursor C = { CXCursor_OverloadedDeclRef, 0, { Storage.getOpaqueValue(), RawLoc, TU } }; return C; } CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name, SourceLocation Loc, CXTranslationUnit TU) { assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate()); CXCursor C = { CXCursor_OverloadedDeclRef, 0, { Storage.getOpaqueValue(), RawLoc, TU } }; return C; } std::pair cxcursor::getCursorOverloadedDeclRef(CXCursor C) { assert(C.kind == CXCursor_OverloadedDeclRef); return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue( const_cast(C.data[0])), SourceLocation::getFromPtrEncoding(C.data[1])); } const Decl *cxcursor::getCursorDecl(CXCursor Cursor) { return static_cast(Cursor.data[0]); } const Expr *cxcursor::getCursorExpr(CXCursor Cursor) { return dyn_cast_or_null(getCursorStmt(Cursor)); } const Stmt *cxcursor::getCursorStmt(CXCursor Cursor) { if (Cursor.kind == CXCursor_ObjCSuperClassRef || Cursor.kind == CXCursor_ObjCProtocolRef || Cursor.kind == CXCursor_ObjCClassRef) return 0; return static_cast(Cursor.data[1]); } const Attr *cxcursor::getCursorAttr(CXCursor Cursor) { return static_cast(Cursor.data[1]); } const Decl *cxcursor::getCursorParentDecl(CXCursor Cursor) { return static_cast(Cursor.data[0]); } ASTContext &cxcursor::getCursorContext(CXCursor Cursor) { return getCursorASTUnit(Cursor)->getASTContext(); } ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) { CXTranslationUnit TU = getCursorTU(Cursor); if (!TU) return 0; return cxtu::getASTUnit(TU); } CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) { return static_cast(const_cast(Cursor.data[2])); } void cxcursor::getOverriddenCursors(CXCursor cursor, SmallVectorImpl &overridden) { assert(clang_isDeclaration(cursor.kind)); const NamedDecl *D = dyn_cast_or_null(getCursorDecl(cursor)); if (!D) return; CXTranslationUnit TU = getCursorTU(cursor); SmallVector OverDecls; D->getASTContext().getOverriddenMethods(D, OverDecls); for (SmallVectorImpl::iterator I = OverDecls.begin(), E = OverDecls.end(); I != E; ++I) { overridden.push_back(MakeCXCursor(*I, TU)); } } std::pair cxcursor::getSelectorIdentifierIndexAndLoc(CXCursor cursor) { if (cursor.kind == CXCursor_ObjCMessageExpr) { if (cursor.xdata != -1) return std::make_pair(cursor.xdata, cast(getCursorExpr(cursor)) ->getSelectorLoc(cursor.xdata)); } else if (cursor.kind == CXCursor_ObjCClassMethodDecl || cursor.kind == CXCursor_ObjCInstanceMethodDecl) { if (cursor.xdata != -1) return std::make_pair(cursor.xdata, cast(getCursorDecl(cursor)) ->getSelectorLoc(cursor.xdata)); } return std::make_pair(-1, SourceLocation()); } CXCursor cxcursor::getSelectorIdentifierCursor(int SelIdx, CXCursor cursor) { CXCursor newCursor = cursor; if (cursor.kind == CXCursor_ObjCMessageExpr) { if (SelIdx == -1 || unsigned(SelIdx) >= cast(getCursorExpr(cursor)) ->getNumSelectorLocs()) newCursor.xdata = -1; else newCursor.xdata = SelIdx; } else if (cursor.kind == CXCursor_ObjCClassMethodDecl || cursor.kind == CXCursor_ObjCInstanceMethodDecl) { if (SelIdx == -1 || unsigned(SelIdx) >= cast(getCursorDecl(cursor)) ->getNumSelectorLocs()) newCursor.xdata = -1; else newCursor.xdata = SelIdx; } return newCursor; } CXCursor cxcursor::getTypeRefCursor(CXCursor cursor) { if (cursor.kind != CXCursor_CallExpr) return cursor; if (cursor.xdata == 0) return cursor; const Expr *E = getCursorExpr(cursor); TypeSourceInfo *Type = 0; if (const CXXUnresolvedConstructExpr * UnCtor = dyn_cast(E)) { Type = UnCtor->getTypeSourceInfo(); } else if (const CXXTemporaryObjectExpr *Tmp = dyn_cast(E)){ Type = Tmp->getTypeSourceInfo(); } if (!Type) return cursor; CXTranslationUnit TU = getCursorTU(cursor); QualType Ty = Type->getType(); TypeLoc TL = Type->getTypeLoc(); SourceLocation Loc = TL.getBeginLoc(); if (const ElaboratedType *ElabT = Ty->getAs()) { Ty = ElabT->getNamedType(); ElaboratedTypeLoc ElabTL = TL.castAs(); Loc = ElabTL.getNamedTypeLoc().getBeginLoc(); } if (const TypedefType *Typedef = Ty->getAs()) return MakeCursorTypeRef(Typedef->getDecl(), Loc, TU); if (const TagType *Tag = Ty->getAs()) return MakeCursorTypeRef(Tag->getDecl(), Loc, TU); if (const TemplateTypeParmType *TemplP = Ty->getAs()) return MakeCursorTypeRef(TemplP->getDecl(), Loc, TU); return cursor; } bool cxcursor::operator==(CXCursor X, CXCursor Y) { return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] && X.data[2] == Y.data[2]; } // FIXME: Remove once we can model DeclGroups and their appropriate ranges // properly in the ASTs. bool cxcursor::isFirstInDeclGroup(CXCursor C) { assert(clang_isDeclaration(C.kind)); return ((uintptr_t) (C.data[1])) != 0; } //===----------------------------------------------------------------------===// // libclang CXCursor APIs //===----------------------------------------------------------------------===// extern "C" { int clang_Cursor_isNull(CXCursor cursor) { return clang_equalCursors(cursor, clang_getNullCursor()); } CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) { return getCursorTU(cursor); } int clang_Cursor_getNumArguments(CXCursor C) { if (clang_isDeclaration(C.kind)) { const Decl *D = cxcursor::getCursorDecl(C); if (const ObjCMethodDecl *MD = dyn_cast_or_null(D)) return MD->param_size(); if (const FunctionDecl *FD = dyn_cast_or_null(D)) return FD->param_size(); } if (clang_isExpression(C.kind)) { const Expr *E = cxcursor::getCursorExpr(C); if (const CallExpr *CE = dyn_cast(E)) { return CE->getNumArgs(); } } return -1; } CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i) { if (clang_isDeclaration(C.kind)) { const Decl *D = cxcursor::getCursorDecl(C); if (const ObjCMethodDecl *MD = dyn_cast_or_null(D)) { if (i < MD->param_size()) return cxcursor::MakeCXCursor(MD->param_begin()[i], cxcursor::getCursorTU(C)); } else if (const FunctionDecl *FD = dyn_cast_or_null(D)) { if (i < FD->param_size()) return cxcursor::MakeCXCursor(FD->param_begin()[i], cxcursor::getCursorTU(C)); } } if (clang_isExpression(C.kind)) { const Expr *E = cxcursor::getCursorExpr(C); if (const CallExpr *CE = dyn_cast(E)) { if (i < CE->getNumArgs()) { return cxcursor::MakeCXCursor(CE->getArg(i), getCursorDecl(C), cxcursor::getCursorTU(C)); } } } return clang_getNullCursor(); } } // end: extern "C" //===----------------------------------------------------------------------===// // CXCursorSet. //===----------------------------------------------------------------------===// typedef llvm::DenseMap CXCursorSet_Impl; static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) { return (CXCursorSet) setImpl; } static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) { return (CXCursorSet_Impl*) set; } namespace llvm { template<> struct DenseMapInfo { public: static inline CXCursor getEmptyKey() { return MakeCXCursorInvalid(CXCursor_InvalidFile); } static inline CXCursor getTombstoneKey() { return MakeCXCursorInvalid(CXCursor_NoDeclFound); } static inline unsigned getHashValue(const CXCursor &cursor) { return llvm::DenseMapInfo > ::getHashValue(std::make_pair(cursor.data[0], cursor.data[1])); } static inline bool isEqual(const CXCursor &x, const CXCursor &y) { return x.kind == y.kind && x.data[0] == y.data[0] && x.data[1] == y.data[1]; } }; } extern "C" { CXCursorSet clang_createCXCursorSet() { return packCXCursorSet(new CXCursorSet_Impl()); } void clang_disposeCXCursorSet(CXCursorSet set) { delete unpackCXCursorSet(set); } unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) { CXCursorSet_Impl *setImpl = unpackCXCursorSet(set); if (!setImpl) return 0; return setImpl->find(cursor) != setImpl->end(); } unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) { // Do not insert invalid cursors into the set. if (cursor.kind >= CXCursor_FirstInvalid && cursor.kind <= CXCursor_LastInvalid) return 1; CXCursorSet_Impl *setImpl = unpackCXCursorSet(set); if (!setImpl) return 1; unsigned &entry = (*setImpl)[cursor]; unsigned flag = entry == 0 ? 1 : 0; entry = 1; return flag; } CXCompletionString clang_getCursorCompletionString(CXCursor cursor) { enum CXCursorKind kind = clang_getCursorKind(cursor); if (clang_isDeclaration(kind)) { const Decl *decl = getCursorDecl(cursor); if (const NamedDecl *namedDecl = dyn_cast_or_null(decl)) { ASTUnit *unit = getCursorASTUnit(cursor); CodeCompletionResult Result(namedDecl, CCP_Declaration); CodeCompletionString *String = Result.CreateCodeCompletionString(unit->getASTContext(), unit->getPreprocessor(), unit->getCodeCompletionTUInfo().getAllocator(), unit->getCodeCompletionTUInfo(), true); return String; } } else if (kind == CXCursor_MacroDefinition) { const MacroDefinition *definition = getCursorMacroDefinition(cursor); const IdentifierInfo *MacroInfo = definition->getName(); ASTUnit *unit = getCursorASTUnit(cursor); CodeCompletionResult Result(MacroInfo); CodeCompletionString *String = Result.CreateCodeCompletionString(unit->getASTContext(), unit->getPreprocessor(), unit->getCodeCompletionTUInfo().getAllocator(), unit->getCodeCompletionTUInfo(), false); return String; } return NULL; } } // end: extern C. namespace { struct OverridenCursorsPool { typedef SmallVector CursorVec; std::vector AllCursors; std::vector AvailableCursors; ~OverridenCursorsPool() { for (std::vector::iterator I = AllCursors.begin(), E = AllCursors.end(); I != E; ++I) { delete *I; } } }; } void *cxcursor::createOverridenCXCursorsPool() { return new OverridenCursorsPool(); } void cxcursor::disposeOverridenCXCursorsPool(void *pool) { delete static_cast(pool); } extern "C" { void clang_getOverriddenCursors(CXCursor cursor, CXCursor **overridden, unsigned *num_overridden) { if (overridden) *overridden = 0; if (num_overridden) *num_overridden = 0; CXTranslationUnit TU = cxcursor::getCursorTU(cursor); if (!overridden || !num_overridden || !TU) return; if (!clang_isDeclaration(cursor.kind)) return; OverridenCursorsPool &pool = *static_cast(TU->OverridenCursorsPool); OverridenCursorsPool::CursorVec *Vec = 0; if (!pool.AvailableCursors.empty()) { Vec = pool.AvailableCursors.back(); pool.AvailableCursors.pop_back(); } else { Vec = new OverridenCursorsPool::CursorVec(); pool.AllCursors.push_back(Vec); } // Clear out the vector, but don't free the memory contents. This // reduces malloc() traffic. Vec->clear(); // Use the first entry to contain a back reference to the vector. // This is a complete hack. CXCursor backRefCursor = MakeCXCursorInvalid(CXCursor_InvalidFile, TU); backRefCursor.data[0] = Vec; assert(cxcursor::getCursorTU(backRefCursor) == TU); Vec->push_back(backRefCursor); // Get the overriden cursors. cxcursor::getOverriddenCursors(cursor, *Vec); // Did we get any overriden cursors? If not, return Vec to the pool // of available cursor vectors. if (Vec->size() == 1) { pool.AvailableCursors.push_back(Vec); return; } // Now tell the caller about the overriden cursors. assert(Vec->size() > 1); *overridden = &((*Vec)[1]); *num_overridden = Vec->size() - 1; } void clang_disposeOverriddenCursors(CXCursor *overridden) { if (!overridden) return; // Use pointer arithmetic to get back the first faux entry // which has a back-reference to the TU and the vector. --overridden; OverridenCursorsPool::CursorVec *Vec = static_cast( const_cast(overridden->data[0])); CXTranslationUnit TU = getCursorTU(*overridden); assert(Vec && TU); OverridenCursorsPool &pool = *static_cast(TU->OverridenCursorsPool); pool.AvailableCursors.push_back(Vec); } int clang_Cursor_isDynamicCall(CXCursor C) { const Expr *E = 0; if (clang_isExpression(C.kind)) E = getCursorExpr(C); if (!E) return 0; if (const ObjCMessageExpr *MsgE = dyn_cast(E)) return MsgE->getReceiverKind() == ObjCMessageExpr::Instance; const MemberExpr *ME = 0; if (isa(E)) ME = cast(E); else if (const CallExpr *CE = dyn_cast(E)) ME = dyn_cast_or_null(CE->getCallee()); if (ME) { if (const CXXMethodDecl * MD = dyn_cast_or_null(ME->getMemberDecl())) return MD->isVirtual() && !ME->hasQualifier(); } return 0; } CXType clang_Cursor_getReceiverType(CXCursor C) { CXTranslationUnit TU = cxcursor::getCursorTU(C); const Expr *E = 0; if (clang_isExpression(C.kind)) E = getCursorExpr(C); if (const ObjCMessageExpr *MsgE = dyn_cast_or_null(E)) return cxtype::MakeCXType(MsgE->getReceiverType(), TU); return cxtype::MakeCXType(QualType(), TU); } } // end: extern "C" @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d216 1 d239 1 @ 1.1.1.3 log @Import Clang 3.5svn r202566. @ text @d512 1 a512 3 case Stmt::OMPSimdDirectiveClass: K = CXCursor_OMPSimdDirective; break; d514 1 a514 1 @ 1.1.1.3.2.1 log @Rebase. @ text @a52 7 case attr::Pure: return CXCursor_PureAttr; case attr::Const: return CXCursor_ConstAttr; case attr::NoDuplicate: return CXCursor_NoDuplicateAttr; case attr::CUDAConstant: return CXCursor_CUDAConstantAttr; case attr::CUDADevice: return CXCursor_CUDADeviceAttr; case attr::CUDAGlobal: return CXCursor_CUDAGlobalAttr; case attr::CUDAHost: return CXCursor_CUDAHostAttr; @ 1.1.1.4 log @Import Clang 3.5svn r209886. @ text @a52 7 case attr::Pure: return CXCursor_PureAttr; case attr::Const: return CXCursor_ConstAttr; case attr::NoDuplicate: return CXCursor_NoDuplicateAttr; case attr::CUDAConstant: return CXCursor_CUDAConstantAttr; case attr::CUDADevice: return CXCursor_CUDADeviceAttr; case attr::CUDAGlobal: return CXCursor_CUDAGlobalAttr; case attr::CUDAHost: return CXCursor_CUDAHostAttr; @ 1.1.1.5 log @Import clang 3.6svn r215315. @ text @d37 1 a37 1 CXCursor C = { K, 0, { nullptr, nullptr, TU } }; a59 1 case attr::CUDAShared: return CXCursor_CUDASharedAttr; a217 4 case Stmt::SEHLeaveStmtClass: K = CXCursor_SEHLeaveStmt; break; a521 45 case Stmt::OMPForDirectiveClass: K = CXCursor_OMPForDirective; break; case Stmt::OMPSectionsDirectiveClass: K = CXCursor_OMPSectionsDirective; break; case Stmt::OMPSectionDirectiveClass: K = CXCursor_OMPSectionDirective; break; case Stmt::OMPSingleDirectiveClass: K = CXCursor_OMPSingleDirective; break; case Stmt::OMPMasterDirectiveClass: K = CXCursor_OMPMasterDirective; break; case Stmt::OMPCriticalDirectiveClass: K = CXCursor_OMPCriticalDirective; break; case Stmt::OMPParallelForDirectiveClass: K = CXCursor_OMPParallelForDirective; break; case Stmt::OMPParallelSectionsDirectiveClass: K = CXCursor_OMPParallelSectionsDirective; break; case Stmt::OMPTaskDirectiveClass: K = CXCursor_OMPTaskDirective; break; case Stmt::OMPTaskyieldDirectiveClass: K = CXCursor_OMPTaskyieldDirective; break; case Stmt::OMPBarrierDirectiveClass: K = CXCursor_OMPBarrierDirective; break; case Stmt::OMPTaskwaitDirectiveClass: K = CXCursor_OMPTaskwaitDirective; break; case Stmt::OMPFlushDirectiveClass: K = CXCursor_OMPFlushDirective; break; case Stmt::OMPOrderedDirectiveClass: K = CXCursor_OMPOrderedDirective; break; case Stmt::OMPAtomicDirectiveClass: K = CXCursor_OMPAtomicDirective; break; d662 1 a662 1 CXCursor C = { CXCursor_CXXBaseSpecifier, 0, { B, nullptr, TU } }; d691 1 a691 1 CXCursor C = { CXCursor_MacroDefinition, 0, { MI, nullptr, TU } }; d702 1 a702 1 CXCursor C = { CXCursor_MacroExpansion, 0, { MI, nullptr, TU } }; d732 1 a732 1 CXCursor C = { CXCursor_InclusionDirective, 0, { ID, nullptr, TU } }; d815 1 a815 1 return nullptr; d835 1 a835 1 return nullptr; d909 1 a909 1 TypeSourceInfo *Type = nullptr; d992 1 a992 1 return cxcursor::MakeCXCursor(MD->parameters()[i], d996 1 a996 1 return cxcursor::MakeCXCursor(FD->parameters()[i], d1110 1 a1110 1 return nullptr; d1142 1 a1142 1 *overridden = nullptr; d1156 3 a1158 3 OverridenCursorsPool::CursorVec *Vec = nullptr; d1216 1 a1216 1 const Expr *E = nullptr; d1225 1 a1225 1 const MemberExpr *ME = nullptr; d1242 1 a1242 1 const Expr *E = nullptr; @ 1.1.1.5.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @a231 1 case Stmt::CXXFoldExprClass: a471 1 case Stmt::TypoExprClass: // A typo could actually be a DeclRef or a MemberRef a529 3 case Stmt::OMPForSimdDirectiveClass: K = CXCursor_OMPForSimdDirective; break; a547 3 case Stmt::OMPParallelForSimdDirectiveClass: K = CXCursor_OMPParallelForSimdDirective; break; a571 6 case Stmt::OMPTargetDirectiveClass: K = CXCursor_OMPTargetDirective; break; case Stmt::OMPTeamsDirectiveClass: K = CXCursor_OMPTeamsDirective; break; a1064 134 int clang_Cursor_getNumTemplateArguments(CXCursor C) { if (clang_getCursorKind(C) != CXCursor_FunctionDecl) { return -1; } const FunctionDecl *FD = llvm::dyn_cast_or_null( getCursorDecl(C)); if (!FD) { return -1; } const FunctionTemplateSpecializationInfo* SpecInfo = FD->getTemplateSpecializationInfo(); if (!SpecInfo) { return -1; } return SpecInfo->TemplateArguments->size(); } enum CXGetTemplateArgumentStatus { /** \brief The operation completed successfully */ CXGetTemplateArgumentStatus_Success = 0, /** \brief The specified cursor did not represent a FunctionDecl. */ CXGetTemplateArgumentStatus_CursorNotFunctionDecl = -1, /** \brief The specified cursor was not castable to a FunctionDecl. */ CXGetTemplateArgumentStatus_BadFunctionDeclCast = -2, /** \brief A NULL FunctionTemplateSpecializationInfo was retrieved. */ CXGetTemplateArgumentStatus_NullTemplSpecInfo = -3, /** \brief An invalid (OOB) argument index was specified */ CXGetTemplateArgumentStatus_InvalidIndex = -4 }; static int clang_Cursor_getTemplateArgument( CXCursor C, unsigned I, TemplateArgument *TA) { if (clang_getCursorKind(C) != CXCursor_FunctionDecl) { return CXGetTemplateArgumentStatus_CursorNotFunctionDecl; } const FunctionDecl *FD = llvm::dyn_cast_or_null( getCursorDecl(C)); if (!FD) { return CXGetTemplateArgumentStatus_BadFunctionDeclCast; } const FunctionTemplateSpecializationInfo* SpecInfo = FD->getTemplateSpecializationInfo(); if (!SpecInfo) { return CXGetTemplateArgumentStatus_NullTemplSpecInfo; } if (I >= SpecInfo->TemplateArguments->size()) { return CXGetTemplateArgumentStatus_InvalidIndex; } *TA = SpecInfo->TemplateArguments->get(I); return 0; } enum CXTemplateArgumentKind clang_Cursor_getTemplateArgumentKind(CXCursor C, unsigned I) { TemplateArgument TA; if (clang_Cursor_getTemplateArgument(C, I, &TA)) { return CXTemplateArgumentKind_Invalid; } switch (TA.getKind()) { case TemplateArgument::Null: return CXTemplateArgumentKind_Null; case TemplateArgument::Type: return CXTemplateArgumentKind_Type; case TemplateArgument::Declaration: return CXTemplateArgumentKind_Declaration; case TemplateArgument::NullPtr: return CXTemplateArgumentKind_NullPtr; case TemplateArgument::Integral: return CXTemplateArgumentKind_Integral; case TemplateArgument::Template: return CXTemplateArgumentKind_Template; case TemplateArgument::TemplateExpansion: return CXTemplateArgumentKind_TemplateExpansion; case TemplateArgument::Expression: return CXTemplateArgumentKind_Expression; case TemplateArgument::Pack: return CXTemplateArgumentKind_Pack; } return CXTemplateArgumentKind_Invalid; } CXType clang_Cursor_getTemplateArgumentType(CXCursor C, unsigned I) { TemplateArgument TA; if (clang_Cursor_getTemplateArgument(C, I, &TA) != CXGetTemplateArgumentStatus_Success) { return cxtype::MakeCXType(QualType(), getCursorTU(C)); } if (TA.getKind() != TemplateArgument::Type) { return cxtype::MakeCXType(QualType(), getCursorTU(C)); } return cxtype::MakeCXType(TA.getAsType(), getCursorTU(C)); } long long clang_Cursor_getTemplateArgumentValue(CXCursor C, unsigned I) { TemplateArgument TA; if (clang_Cursor_getTemplateArgument(C, I, &TA) != CXGetTemplateArgumentStatus_Success) { assert(0 && "Unable to retrieve TemplateArgument"); return 0; } if (TA.getKind() != TemplateArgument::Integral) { assert(0 && "Passed template argument is not Integral"); return 0; } return TA.getAsIntegral().getSExtValue(); } unsigned long long clang_Cursor_getTemplateArgumentUnsignedValue(CXCursor C, unsigned I) { TemplateArgument TA; if (clang_Cursor_getTemplateArgument(C, I, &TA) != CXGetTemplateArgumentStatus_Success) { assert(0 && "Unable to retrieve TemplateArgument"); return 0; } if (TA.getKind() != TemplateArgument::Integral) { assert(0 && "Passed template argument is not Integral"); return 0; } return TA.getAsIntegral().getZExtValue(); } d1272 2 a1273 10 if (const ObjCMessageExpr *MsgE = dyn_cast(E)) { if (MsgE->getReceiverKind() != ObjCMessageExpr::Instance) return false; if (auto *RecE = dyn_cast( MsgE->getInstanceReceiver()->IgnoreParenCasts())) { if (RecE->getMethodFamily() == OMF_alloc) return false; } return true; } @ 1.1.1.6 log @Import Clang 3.6RC1 r227398. @ text @a231 1 case Stmt::CXXFoldExprClass: a471 1 case Stmt::TypoExprClass: // A typo could actually be a DeclRef or a MemberRef a529 3 case Stmt::OMPForSimdDirectiveClass: K = CXCursor_OMPForSimdDirective; break; a547 3 case Stmt::OMPParallelForSimdDirectiveClass: K = CXCursor_OMPParallelForSimdDirective; break; a571 6 case Stmt::OMPTargetDirectiveClass: K = CXCursor_OMPTargetDirective; break; case Stmt::OMPTeamsDirectiveClass: K = CXCursor_OMPTeamsDirective; break; a1064 134 int clang_Cursor_getNumTemplateArguments(CXCursor C) { if (clang_getCursorKind(C) != CXCursor_FunctionDecl) { return -1; } const FunctionDecl *FD = llvm::dyn_cast_or_null( getCursorDecl(C)); if (!FD) { return -1; } const FunctionTemplateSpecializationInfo* SpecInfo = FD->getTemplateSpecializationInfo(); if (!SpecInfo) { return -1; } return SpecInfo->TemplateArguments->size(); } enum CXGetTemplateArgumentStatus { /** \brief The operation completed successfully */ CXGetTemplateArgumentStatus_Success = 0, /** \brief The specified cursor did not represent a FunctionDecl. */ CXGetTemplateArgumentStatus_CursorNotFunctionDecl = -1, /** \brief The specified cursor was not castable to a FunctionDecl. */ CXGetTemplateArgumentStatus_BadFunctionDeclCast = -2, /** \brief A NULL FunctionTemplateSpecializationInfo was retrieved. */ CXGetTemplateArgumentStatus_NullTemplSpecInfo = -3, /** \brief An invalid (OOB) argument index was specified */ CXGetTemplateArgumentStatus_InvalidIndex = -4 }; static int clang_Cursor_getTemplateArgument( CXCursor C, unsigned I, TemplateArgument *TA) { if (clang_getCursorKind(C) != CXCursor_FunctionDecl) { return CXGetTemplateArgumentStatus_CursorNotFunctionDecl; } const FunctionDecl *FD = llvm::dyn_cast_or_null( getCursorDecl(C)); if (!FD) { return CXGetTemplateArgumentStatus_BadFunctionDeclCast; } const FunctionTemplateSpecializationInfo* SpecInfo = FD->getTemplateSpecializationInfo(); if (!SpecInfo) { return CXGetTemplateArgumentStatus_NullTemplSpecInfo; } if (I >= SpecInfo->TemplateArguments->size()) { return CXGetTemplateArgumentStatus_InvalidIndex; } *TA = SpecInfo->TemplateArguments->get(I); return 0; } enum CXTemplateArgumentKind clang_Cursor_getTemplateArgumentKind(CXCursor C, unsigned I) { TemplateArgument TA; if (clang_Cursor_getTemplateArgument(C, I, &TA)) { return CXTemplateArgumentKind_Invalid; } switch (TA.getKind()) { case TemplateArgument::Null: return CXTemplateArgumentKind_Null; case TemplateArgument::Type: return CXTemplateArgumentKind_Type; case TemplateArgument::Declaration: return CXTemplateArgumentKind_Declaration; case TemplateArgument::NullPtr: return CXTemplateArgumentKind_NullPtr; case TemplateArgument::Integral: return CXTemplateArgumentKind_Integral; case TemplateArgument::Template: return CXTemplateArgumentKind_Template; case TemplateArgument::TemplateExpansion: return CXTemplateArgumentKind_TemplateExpansion; case TemplateArgument::Expression: return CXTemplateArgumentKind_Expression; case TemplateArgument::Pack: return CXTemplateArgumentKind_Pack; } return CXTemplateArgumentKind_Invalid; } CXType clang_Cursor_getTemplateArgumentType(CXCursor C, unsigned I) { TemplateArgument TA; if (clang_Cursor_getTemplateArgument(C, I, &TA) != CXGetTemplateArgumentStatus_Success) { return cxtype::MakeCXType(QualType(), getCursorTU(C)); } if (TA.getKind() != TemplateArgument::Type) { return cxtype::MakeCXType(QualType(), getCursorTU(C)); } return cxtype::MakeCXType(TA.getAsType(), getCursorTU(C)); } long long clang_Cursor_getTemplateArgumentValue(CXCursor C, unsigned I) { TemplateArgument TA; if (clang_Cursor_getTemplateArgument(C, I, &TA) != CXGetTemplateArgumentStatus_Success) { assert(0 && "Unable to retrieve TemplateArgument"); return 0; } if (TA.getKind() != TemplateArgument::Integral) { assert(0 && "Passed template argument is not Integral"); return 0; } return TA.getAsIntegral().getSExtValue(); } unsigned long long clang_Cursor_getTemplateArgumentUnsignedValue(CXCursor C, unsigned I) { TemplateArgument TA; if (clang_Cursor_getTemplateArgument(C, I, &TA) != CXGetTemplateArgumentStatus_Success) { assert(0 && "Unable to retrieve TemplateArgument"); return 0; } if (TA.getKind() != TemplateArgument::Integral) { assert(0 && "Passed template argument is not Integral"); return 0; } return TA.getAsIntegral().getZExtValue(); } d1272 2 a1273 10 if (const ObjCMessageExpr *MsgE = dyn_cast(E)) { if (MsgE->getReceiverKind() != ObjCMessageExpr::Instance) return false; if (auto *RecE = dyn_cast( MsgE->getInstanceReceiver()->IgnoreParenCasts())) { if (RecE->getMethodFamily() == OMF_alloc) return false; } return true; } @ 1.1.1.7 log @Import Clang 3.8.0rc3 r261930. @ text @a60 3 case attr::Visibility: return CXCursor_VisibilityAttr; case attr::DLLExport: return CXCursor_DLLExport; case attr::DLLImport: return CXCursor_DLLImport; a228 4 case Stmt::CoroutineBodyStmtClass: case Stmt::CoawaitExprClass: case Stmt::CoreturnStmtClass: case Stmt::CoyieldExprClass: a237 1 case Stmt::DesignatedInitUpdateExprClass: a242 1 case Stmt::NoInitExprClass: a324 1 case Stmt::MSPropertySubscriptExprClass: a328 4 case Stmt::OMPArraySectionExprClass: K = CXCursor_OMPArraySectionExpr; break; a570 3 case Stmt::OMPTaskgroupDirectiveClass: K = CXCursor_OMPTaskgroupDirective; break; a582 3 case Stmt::OMPTargetDataDirectiveClass: K = CXCursor_OMPTargetDataDirective; break; a585 15 case Stmt::OMPCancellationPointDirectiveClass: K = CXCursor_OMPCancellationPointDirective; break; case Stmt::OMPCancelDirectiveClass: K = CXCursor_OMPCancelDirective; break; case Stmt::OMPTaskLoopDirectiveClass: K = CXCursor_OMPTaskLoopDirective; break; case Stmt::OMPTaskLoopSimdDirectiveClass: K = CXCursor_OMPTaskLoopSimdDirective; break; case Stmt::OMPDistributeDirectiveClass: K = CXCursor_OMPDistributeDirective; break; d753 1 a753 1 CXCursor cxcursor::MakeMacroDefinitionCursor(const MacroDefinitionRecord *MI, d755 1 a755 1 CXCursor C = {CXCursor_MacroDefinition, 0, {MI, nullptr, TU}}; d759 1 a759 1 const MacroDefinitionRecord *cxcursor::getCursorMacroDefinition(CXCursor C) { d761 1 a761 1 return static_cast(C.data[0]); d764 1 a764 1 CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI, d770 1 a770 1 CXCursor cxcursor::MakeMacroExpansionCursor(MacroDefinitionRecord *MI, d774 1 a774 1 CXCursor C = {CXCursor_MacroExpansion, 0, {MI, Loc.getPtrEncoding(), TU}}; d783 1 a783 2 const MacroDefinitionRecord * cxcursor::MacroExpansionCursor::getDefinition() const { a1288 1 CodeCompletionContext::CCC_Other, d1294 3 a1296 2 } else if (kind == CXCursor_MacroDefinition) { const MacroDefinitionRecord *definition = getCursorMacroDefinition(cursor); a1302 1 CodeCompletionContext::CCC_Other, @ 1.1.1.7.2.1 log @Sync with HEAD @ text @a245 2 case Stmt::ArrayInitLoopExprClass: case Stmt::ArrayInitIndexExprClass: d259 1 a329 1 case Stmt::UnaryExprOrTypeTraitExprClass: d450 1 a450 5 case Stmt::ObjCAvailabilityCheckExprClass: K = CXCursor_ObjCAvailabilityCheckExpr; break; a506 1 case Stmt::CXXInheritedCtorInitExprClass: a602 15 case Stmt::OMPTargetEnterDataDirectiveClass: K = CXCursor_OMPTargetEnterDataDirective; break; case Stmt::OMPTargetExitDataDirectiveClass: K = CXCursor_OMPTargetExitDataDirective; break; case Stmt::OMPTargetParallelDirectiveClass: K = CXCursor_OMPTargetParallelDirective; break; case Stmt::OMPTargetParallelForDirectiveClass: K = CXCursor_OMPTargetParallelForDirective; break; case Stmt::OMPTargetUpdateDirectiveClass: K = CXCursor_OMPTargetUpdateDirective; break; a620 42 case Stmt::OMPDistributeParallelForDirectiveClass: K = CXCursor_OMPDistributeParallelForDirective; break; case Stmt::OMPDistributeParallelForSimdDirectiveClass: K = CXCursor_OMPDistributeParallelForSimdDirective; break; case Stmt::OMPDistributeSimdDirectiveClass: K = CXCursor_OMPDistributeSimdDirective; break; case Stmt::OMPTargetParallelForSimdDirectiveClass: K = CXCursor_OMPTargetParallelForSimdDirective; break; case Stmt::OMPTargetSimdDirectiveClass: K = CXCursor_OMPTargetSimdDirective; break; case Stmt::OMPTeamsDistributeDirectiveClass: K = CXCursor_OMPTeamsDistributeDirective; break; case Stmt::OMPTeamsDistributeSimdDirectiveClass: K = CXCursor_OMPTeamsDistributeSimdDirective; break; case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass: K = CXCursor_OMPTeamsDistributeParallelForSimdDirective; break; case Stmt::OMPTeamsDistributeParallelForDirectiveClass: K = CXCursor_OMPTeamsDistributeParallelForDirective; break; case Stmt::OMPTargetTeamsDirectiveClass: K = CXCursor_OMPTargetTeamsDirective; break; case Stmt::OMPTargetTeamsDistributeDirectiveClass: K = CXCursor_OMPTargetTeamsDistributeDirective; break; case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass: K = CXCursor_OMPTargetTeamsDistributeParallelForDirective; break; case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass: K = CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective; break; case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: K = CXCursor_OMPTargetTeamsDistributeSimdDirective; break; d1058 2 d1249 2 d1284 1 d1347 1 d1372 1 d1494 2 @ 1.1.1.8 log @Import Clang pre-4.0.0 r291444. @ text @a245 2 case Stmt::ArrayInitLoopExprClass: case Stmt::ArrayInitIndexExprClass: d259 1 a329 1 case Stmt::UnaryExprOrTypeTraitExprClass: d450 1 a450 5 case Stmt::ObjCAvailabilityCheckExprClass: K = CXCursor_ObjCAvailabilityCheckExpr; break; a506 1 case Stmt::CXXInheritedCtorInitExprClass: a602 15 case Stmt::OMPTargetEnterDataDirectiveClass: K = CXCursor_OMPTargetEnterDataDirective; break; case Stmt::OMPTargetExitDataDirectiveClass: K = CXCursor_OMPTargetExitDataDirective; break; case Stmt::OMPTargetParallelDirectiveClass: K = CXCursor_OMPTargetParallelDirective; break; case Stmt::OMPTargetParallelForDirectiveClass: K = CXCursor_OMPTargetParallelForDirective; break; case Stmt::OMPTargetUpdateDirectiveClass: K = CXCursor_OMPTargetUpdateDirective; break; a620 39 case Stmt::OMPDistributeParallelForDirectiveClass: K = CXCursor_OMPDistributeParallelForDirective; break; case Stmt::OMPDistributeParallelForSimdDirectiveClass: K = CXCursor_OMPDistributeParallelForSimdDirective; break; case Stmt::OMPDistributeSimdDirectiveClass: K = CXCursor_OMPDistributeSimdDirective; break; case Stmt::OMPTargetParallelForSimdDirectiveClass: K = CXCursor_OMPTargetParallelForSimdDirective; break; case Stmt::OMPTargetSimdDirectiveClass: K = CXCursor_OMPTargetSimdDirective; break; case Stmt::OMPTeamsDistributeDirectiveClass: K = CXCursor_OMPTeamsDistributeDirective; break; case Stmt::OMPTeamsDistributeSimdDirectiveClass: K = CXCursor_OMPTeamsDistributeSimdDirective; break; case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass: K = CXCursor_OMPTeamsDistributeParallelForSimdDirective; break; case Stmt::OMPTeamsDistributeParallelForDirectiveClass: K = CXCursor_OMPTeamsDistributeParallelForDirective; break; case Stmt::OMPTargetTeamsDirectiveClass: K = CXCursor_OMPTargetTeamsDirective; break; case Stmt::OMPTargetTeamsDistributeDirectiveClass: K = CXCursor_OMPTargetTeamsDistributeDirective; break; case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass: K = CXCursor_OMPTargetTeamsDistributeParallelForDirective; break; case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass: K = CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective; break; d1058 2 d1249 2 d1284 1 d1347 1 d1372 1 d1494 2 @ 1.1.1.8.2.1 log @Sync with HEAD @ text @a681 3 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: K = CXCursor_OMPTargetTeamsDistributeSimdDirective; break; @ 1.1.1.9 log @Import Clang 4.0RC1 r294123. @ text @a681 3 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: K = CXCursor_OMPTargetTeamsDistributeSimdDirective; break; @ 1.1.1.10 log @Import clang r309604 from branches/release_50 @ text @a233 1 case Stmt::DependentCoawaitExprClass: a1524 4 if (auto *PropRefE = dyn_cast(E)) { return !PropRefE->isSuperReceiver(); } d1534 1 a1534 3 return MD->isVirtual() && ME->performsVirtualDispatch( cxcursor::getCursorContext(C).getLangOpts()); a1548 18 if (auto *PropRefE = dyn_cast(E)) { return cxtype::MakeCXType( PropRefE->getReceiverType(cxcursor::getCursorContext(C)), TU); } const MemberExpr *ME = nullptr; if (isa(E)) ME = cast(E); else if (const CallExpr *CE = dyn_cast(E)) ME = dyn_cast_or_null(CE->getCallee()); if (ME) { if (dyn_cast_or_null(ME->getMemberDecl())) { auto receiverTy = ME->getBase()->IgnoreImpCasts()->getType(); return cxtype::MakeCXType(receiverTy, TU); } } @ 1.1.1.10.4.1 log @Sync with HEAD @ text @a307 4 case Stmt::FixedPointLiteralClass: K = CXCursor_FixedPointLiteral; break; d1199 1 a1199 1 /** The operation completed successfully */ d1202 1 a1202 1 /** The specified cursor did not represent a FunctionDecl. */ d1205 1 a1205 1 /** The specified cursor was not castable to a FunctionDecl. */ d1208 1 a1208 1 /** A NULL FunctionTemplateSpecializationInfo was retrieved. */ d1211 1 a1211 1 /** An invalid (OOB) argument index was specified */ d1472 1 a1472 1 // Get the overridden cursors. d1475 1 a1475 1 // Did we get any overridden cursors? If not, return Vec to the pool d1482 1 a1482 1 // Now tell the caller about the overridden cursors. @ 1.1.1.10.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.10.2.1 log @Sync with HEAD @ text @a307 4 case Stmt::FixedPointLiteralClass: K = CXCursor_FixedPointLiteral; break; d1199 1 a1199 1 /** The operation completed successfully */ d1202 1 a1202 1 /** The specified cursor did not represent a FunctionDecl. */ d1205 1 a1205 1 /** The specified cursor was not castable to a FunctionDecl. */ d1208 1 a1208 1 /** A NULL FunctionTemplateSpecializationInfo was retrieved. */ d1211 1 a1211 1 /** An invalid (OOB) argument index was specified */ d1472 1 a1472 1 // Get the overridden cursors. d1475 1 a1475 1 // Did we get any overridden cursors? If not, return Vec to the pool d1482 1 a1482 1 // Now tell the caller about the overridden cursors. @ 1.1.1.11 log @Import clang r337282 from trunk @ text @a307 4 case Stmt::FixedPointLiteralClass: K = CXCursor_FixedPointLiteral; break; d1199 1 a1199 1 /** The operation completed successfully */ d1202 1 a1202 1 /** The specified cursor did not represent a FunctionDecl. */ d1205 1 a1205 1 /** The specified cursor was not castable to a FunctionDecl. */ d1208 1 a1208 1 /** A NULL FunctionTemplateSpecializationInfo was retrieved. */ d1211 1 a1211 1 /** An invalid (OOB) argument index was specified */ d1472 1 a1472 1 // Get the overridden cursors. d1475 1 a1475 1 // Did we get any overridden cursors? If not, return Vec to the pool d1482 1 a1482 1 // Now tell the caller about the overridden cursors. @ 1.1.1.12 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.5.4.1 log @file CXCursor.cpp was added on branch tls-maxphys on 2014-08-19 23:49:27 +0000 @ text @d1 1302 @ 1.1.1.5.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 1302 //===- CXCursor.cpp - Routines for manipulating CXCursors -----------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines routines for manipulating CXCursors. It should be the // only file that has internal knowledge of the encoding of the data in // CXCursor. // //===----------------------------------------------------------------------===// #include "CXTranslationUnit.h" #include "CXCursor.h" #include "CXString.h" #include "CXType.h" #include "clang-c/Index.h" #include "clang/AST/Attr.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/ExprObjC.h" #include "clang/Frontend/ASTUnit.h" #include "llvm/Support/ErrorHandling.h" using namespace clang; using namespace cxcursor; CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K, CXTranslationUnit TU) { assert(K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid); CXCursor C = { K, 0, { nullptr, nullptr, TU } }; return C; } static CXCursorKind GetCursorKind(const Attr *A) { assert(A && "Invalid arguments!"); switch (A->getKind()) { default: break; case attr::IBAction: return CXCursor_IBActionAttr; case attr::IBOutlet: return CXCursor_IBOutletAttr; case attr::IBOutletCollection: return CXCursor_IBOutletCollectionAttr; case attr::Final: return CXCursor_CXXFinalAttr; case attr::Override: return CXCursor_CXXOverrideAttr; case attr::Annotate: return CXCursor_AnnotateAttr; case attr::AsmLabel: return CXCursor_AsmLabelAttr; case attr::Packed: return CXCursor_PackedAttr; case attr::Pure: return CXCursor_PureAttr; case attr::Const: return CXCursor_ConstAttr; case attr::NoDuplicate: return CXCursor_NoDuplicateAttr; case attr::CUDAConstant: return CXCursor_CUDAConstantAttr; case attr::CUDADevice: return CXCursor_CUDADeviceAttr; case attr::CUDAGlobal: return CXCursor_CUDAGlobalAttr; case attr::CUDAHost: return CXCursor_CUDAHostAttr; case attr::CUDAShared: return CXCursor_CUDASharedAttr; } return CXCursor_UnexposedAttr; } CXCursor cxcursor::MakeCXCursor(const Attr *A, const Decl *Parent, CXTranslationUnit TU) { assert(A && Parent && TU && "Invalid arguments!"); CXCursor C = { GetCursorKind(A), 0, { Parent, A, TU } }; return C; } CXCursor cxcursor::MakeCXCursor(const Decl *D, CXTranslationUnit TU, SourceRange RegionOfInterest, bool FirstInDeclGroup) { assert(D && TU && "Invalid arguments!"); CXCursorKind K = getCursorKindForDecl(D); if (K == CXCursor_ObjCClassMethodDecl || K == CXCursor_ObjCInstanceMethodDecl) { int SelectorIdIndex = -1; // Check if cursor points to a selector id. if (RegionOfInterest.isValid() && RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) { SmallVector SelLocs; cast(D)->getSelectorLocs(SelLocs); SmallVectorImpl::iterator I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin()); if (I != SelLocs.end()) SelectorIdIndex = I - SelLocs.begin(); } CXCursor C = { K, SelectorIdIndex, { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }}; return C; } CXCursor C = { K, 0, { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }}; return C; } CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent, CXTranslationUnit TU, SourceRange RegionOfInterest) { assert(S && TU && "Invalid arguments!"); CXCursorKind K = CXCursor_NotImplemented; switch (S->getStmtClass()) { case Stmt::NoStmtClass: break; case Stmt::CaseStmtClass: K = CXCursor_CaseStmt; break; case Stmt::DefaultStmtClass: K = CXCursor_DefaultStmt; break; case Stmt::IfStmtClass: K = CXCursor_IfStmt; break; case Stmt::SwitchStmtClass: K = CXCursor_SwitchStmt; break; case Stmt::WhileStmtClass: K = CXCursor_WhileStmt; break; case Stmt::DoStmtClass: K = CXCursor_DoStmt; break; case Stmt::ForStmtClass: K = CXCursor_ForStmt; break; case Stmt::GotoStmtClass: K = CXCursor_GotoStmt; break; case Stmt::IndirectGotoStmtClass: K = CXCursor_IndirectGotoStmt; break; case Stmt::ContinueStmtClass: K = CXCursor_ContinueStmt; break; case Stmt::BreakStmtClass: K = CXCursor_BreakStmt; break; case Stmt::ReturnStmtClass: K = CXCursor_ReturnStmt; break; case Stmt::GCCAsmStmtClass: K = CXCursor_GCCAsmStmt; break; case Stmt::MSAsmStmtClass: K = CXCursor_MSAsmStmt; break; case Stmt::ObjCAtTryStmtClass: K = CXCursor_ObjCAtTryStmt; break; case Stmt::ObjCAtCatchStmtClass: K = CXCursor_ObjCAtCatchStmt; break; case Stmt::ObjCAtFinallyStmtClass: K = CXCursor_ObjCAtFinallyStmt; break; case Stmt::ObjCAtThrowStmtClass: K = CXCursor_ObjCAtThrowStmt; break; case Stmt::ObjCAtSynchronizedStmtClass: K = CXCursor_ObjCAtSynchronizedStmt; break; case Stmt::ObjCAutoreleasePoolStmtClass: K = CXCursor_ObjCAutoreleasePoolStmt; break; case Stmt::ObjCForCollectionStmtClass: K = CXCursor_ObjCForCollectionStmt; break; case Stmt::CXXCatchStmtClass: K = CXCursor_CXXCatchStmt; break; case Stmt::CXXTryStmtClass: K = CXCursor_CXXTryStmt; break; case Stmt::CXXForRangeStmtClass: K = CXCursor_CXXForRangeStmt; break; case Stmt::SEHTryStmtClass: K = CXCursor_SEHTryStmt; break; case Stmt::SEHExceptStmtClass: K = CXCursor_SEHExceptStmt; break; case Stmt::SEHFinallyStmtClass: K = CXCursor_SEHFinallyStmt; break; case Stmt::SEHLeaveStmtClass: K = CXCursor_SEHLeaveStmt; break; case Stmt::ArrayTypeTraitExprClass: case Stmt::AsTypeExprClass: case Stmt::AtomicExprClass: case Stmt::BinaryConditionalOperatorClass: case Stmt::TypeTraitExprClass: case Stmt::CXXBindTemporaryExprClass: case Stmt::CXXDefaultArgExprClass: case Stmt::CXXDefaultInitExprClass: case Stmt::CXXStdInitializerListExprClass: case Stmt::CXXScalarValueInitExprClass: case Stmt::CXXUuidofExprClass: case Stmt::ChooseExprClass: case Stmt::DesignatedInitExprClass: case Stmt::ExprWithCleanupsClass: case Stmt::ExpressionTraitExprClass: case Stmt::ExtVectorElementExprClass: case Stmt::ImplicitCastExprClass: case Stmt::ImplicitValueInitExprClass: case Stmt::MaterializeTemporaryExprClass: case Stmt::ObjCIndirectCopyRestoreExprClass: case Stmt::OffsetOfExprClass: case Stmt::ParenListExprClass: case Stmt::PredefinedExprClass: case Stmt::ShuffleVectorExprClass: case Stmt::ConvertVectorExprClass: case Stmt::UnaryExprOrTypeTraitExprClass: case Stmt::VAArgExprClass: case Stmt::ObjCArrayLiteralClass: case Stmt::ObjCDictionaryLiteralClass: case Stmt::ObjCBoxedExprClass: case Stmt::ObjCSubscriptRefExprClass: K = CXCursor_UnexposedExpr; break; case Stmt::OpaqueValueExprClass: if (Expr *Src = cast(S)->getSourceExpr()) return MakeCXCursor(Src, Parent, TU, RegionOfInterest); K = CXCursor_UnexposedExpr; break; case Stmt::PseudoObjectExprClass: return MakeCXCursor(cast(S)->getSyntacticForm(), Parent, TU, RegionOfInterest); case Stmt::CompoundStmtClass: K = CXCursor_CompoundStmt; break; case Stmt::NullStmtClass: K = CXCursor_NullStmt; break; case Stmt::LabelStmtClass: K = CXCursor_LabelStmt; break; case Stmt::AttributedStmtClass: K = CXCursor_UnexposedStmt; break; case Stmt::DeclStmtClass: K = CXCursor_DeclStmt; break; case Stmt::CapturedStmtClass: K = CXCursor_UnexposedStmt; break; case Stmt::IntegerLiteralClass: K = CXCursor_IntegerLiteral; break; case Stmt::FloatingLiteralClass: K = CXCursor_FloatingLiteral; break; case Stmt::ImaginaryLiteralClass: K = CXCursor_ImaginaryLiteral; break; case Stmt::StringLiteralClass: K = CXCursor_StringLiteral; break; case Stmt::CharacterLiteralClass: K = CXCursor_CharacterLiteral; break; case Stmt::ParenExprClass: K = CXCursor_ParenExpr; break; case Stmt::UnaryOperatorClass: K = CXCursor_UnaryOperator; break; case Stmt::CXXNoexceptExprClass: K = CXCursor_UnaryExpr; break; case Stmt::ArraySubscriptExprClass: K = CXCursor_ArraySubscriptExpr; break; case Stmt::BinaryOperatorClass: K = CXCursor_BinaryOperator; break; case Stmt::CompoundAssignOperatorClass: K = CXCursor_CompoundAssignOperator; break; case Stmt::ConditionalOperatorClass: K = CXCursor_ConditionalOperator; break; case Stmt::CStyleCastExprClass: K = CXCursor_CStyleCastExpr; break; case Stmt::CompoundLiteralExprClass: K = CXCursor_CompoundLiteralExpr; break; case Stmt::InitListExprClass: K = CXCursor_InitListExpr; break; case Stmt::AddrLabelExprClass: K = CXCursor_AddrLabelExpr; break; case Stmt::StmtExprClass: K = CXCursor_StmtExpr; break; case Stmt::GenericSelectionExprClass: K = CXCursor_GenericSelectionExpr; break; case Stmt::GNUNullExprClass: K = CXCursor_GNUNullExpr; break; case Stmt::CXXStaticCastExprClass: K = CXCursor_CXXStaticCastExpr; break; case Stmt::CXXDynamicCastExprClass: K = CXCursor_CXXDynamicCastExpr; break; case Stmt::CXXReinterpretCastExprClass: K = CXCursor_CXXReinterpretCastExpr; break; case Stmt::CXXConstCastExprClass: K = CXCursor_CXXConstCastExpr; break; case Stmt::CXXFunctionalCastExprClass: K = CXCursor_CXXFunctionalCastExpr; break; case Stmt::CXXTypeidExprClass: K = CXCursor_CXXTypeidExpr; break; case Stmt::CXXBoolLiteralExprClass: K = CXCursor_CXXBoolLiteralExpr; break; case Stmt::CXXNullPtrLiteralExprClass: K = CXCursor_CXXNullPtrLiteralExpr; break; case Stmt::CXXThisExprClass: K = CXCursor_CXXThisExpr; break; case Stmt::CXXThrowExprClass: K = CXCursor_CXXThrowExpr; break; case Stmt::CXXNewExprClass: K = CXCursor_CXXNewExpr; break; case Stmt::CXXDeleteExprClass: K = CXCursor_CXXDeleteExpr; break; case Stmt::ObjCStringLiteralClass: K = CXCursor_ObjCStringLiteral; break; case Stmt::ObjCEncodeExprClass: K = CXCursor_ObjCEncodeExpr; break; case Stmt::ObjCSelectorExprClass: K = CXCursor_ObjCSelectorExpr; break; case Stmt::ObjCProtocolExprClass: K = CXCursor_ObjCProtocolExpr; break; case Stmt::ObjCBoolLiteralExprClass: K = CXCursor_ObjCBoolLiteralExpr; break; case Stmt::ObjCBridgedCastExprClass: K = CXCursor_ObjCBridgedCastExpr; break; case Stmt::BlockExprClass: K = CXCursor_BlockExpr; break; case Stmt::PackExpansionExprClass: K = CXCursor_PackExpansionExpr; break; case Stmt::SizeOfPackExprClass: K = CXCursor_SizeOfPackExpr; break; case Stmt::DeclRefExprClass: if (const ImplicitParamDecl *IPD = dyn_cast_or_null(cast(S)->getDecl())) { if (const ObjCMethodDecl *MD = dyn_cast(IPD->getDeclContext())) { if (MD->getSelfDecl() == IPD) { K = CXCursor_ObjCSelfExpr; break; } } } K = CXCursor_DeclRefExpr; break; case Stmt::DependentScopeDeclRefExprClass: case Stmt::SubstNonTypeTemplateParmExprClass: case Stmt::SubstNonTypeTemplateParmPackExprClass: case Stmt::FunctionParmPackExprClass: case Stmt::UnresolvedLookupExprClass: K = CXCursor_DeclRefExpr; break; case Stmt::CXXDependentScopeMemberExprClass: case Stmt::CXXPseudoDestructorExprClass: case Stmt::MemberExprClass: case Stmt::MSPropertyRefExprClass: case Stmt::ObjCIsaExprClass: case Stmt::ObjCIvarRefExprClass: case Stmt::ObjCPropertyRefExprClass: case Stmt::UnresolvedMemberExprClass: K = CXCursor_MemberRefExpr; break; case Stmt::CallExprClass: case Stmt::CXXOperatorCallExprClass: case Stmt::CXXMemberCallExprClass: case Stmt::CUDAKernelCallExprClass: case Stmt::CXXConstructExprClass: case Stmt::CXXTemporaryObjectExprClass: case Stmt::CXXUnresolvedConstructExprClass: case Stmt::UserDefinedLiteralClass: K = CXCursor_CallExpr; break; case Stmt::LambdaExprClass: K = CXCursor_LambdaExpr; break; case Stmt::ObjCMessageExprClass: { K = CXCursor_ObjCMessageExpr; int SelectorIdIndex = -1; // Check if cursor points to a selector id. if (RegionOfInterest.isValid() && RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) { SmallVector SelLocs; cast(S)->getSelectorLocs(SelLocs); SmallVectorImpl::iterator I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin()); if (I != SelLocs.end()) SelectorIdIndex = I - SelLocs.begin(); } CXCursor C = { K, 0, { Parent, S, TU } }; return getSelectorIdentifierCursor(SelectorIdIndex, C); } case Stmt::MSDependentExistsStmtClass: K = CXCursor_UnexposedStmt; break; case Stmt::OMPParallelDirectiveClass: K = CXCursor_OMPParallelDirective; break; case Stmt::OMPSimdDirectiveClass: K = CXCursor_OMPSimdDirective; break; case Stmt::OMPForDirectiveClass: K = CXCursor_OMPForDirective; break; case Stmt::OMPSectionsDirectiveClass: K = CXCursor_OMPSectionsDirective; break; case Stmt::OMPSectionDirectiveClass: K = CXCursor_OMPSectionDirective; break; case Stmt::OMPSingleDirectiveClass: K = CXCursor_OMPSingleDirective; break; case Stmt::OMPMasterDirectiveClass: K = CXCursor_OMPMasterDirective; break; case Stmt::OMPCriticalDirectiveClass: K = CXCursor_OMPCriticalDirective; break; case Stmt::OMPParallelForDirectiveClass: K = CXCursor_OMPParallelForDirective; break; case Stmt::OMPParallelSectionsDirectiveClass: K = CXCursor_OMPParallelSectionsDirective; break; case Stmt::OMPTaskDirectiveClass: K = CXCursor_OMPTaskDirective; break; case Stmt::OMPTaskyieldDirectiveClass: K = CXCursor_OMPTaskyieldDirective; break; case Stmt::OMPBarrierDirectiveClass: K = CXCursor_OMPBarrierDirective; break; case Stmt::OMPTaskwaitDirectiveClass: K = CXCursor_OMPTaskwaitDirective; break; case Stmt::OMPFlushDirectiveClass: K = CXCursor_OMPFlushDirective; break; case Stmt::OMPOrderedDirectiveClass: K = CXCursor_OMPOrderedDirective; break; case Stmt::OMPAtomicDirectiveClass: K = CXCursor_OMPAtomicDirective; break; } CXCursor C = { K, 0, { Parent, S, TU } }; return C; } CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super, SourceLocation Loc, CXTranslationUnit TU) { assert(Super && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_ObjCSuperClassRef, 0, { Super, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorObjCSuperClassRef(CXCursor C) { assert(C.kind == CXCursor_ObjCSuperClassRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorObjCProtocolRef(const ObjCProtocolDecl *Proto, SourceLocation Loc, CXTranslationUnit TU) { assert(Proto && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_ObjCProtocolRef, 0, { Proto, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorObjCProtocolRef(CXCursor C) { assert(C.kind == CXCursor_ObjCProtocolRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorObjCClassRef(const ObjCInterfaceDecl *Class, SourceLocation Loc, CXTranslationUnit TU) { // 'Class' can be null for invalid code. if (!Class) return MakeCXCursorInvalid(CXCursor_InvalidCode); assert(TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_ObjCClassRef, 0, { Class, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorObjCClassRef(CXCursor C) { assert(C.kind == CXCursor_ObjCClassRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorTypeRef(const TypeDecl *Type, SourceLocation Loc, CXTranslationUnit TU) { assert(Type && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_TypeRef, 0, { Type, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorTypeRef(CXCursor C) { assert(C.kind == CXCursor_TypeRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorTemplateRef(const TemplateDecl *Template, SourceLocation Loc, CXTranslationUnit TU) { assert(Template && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_TemplateRef, 0, { Template, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorTemplateRef(CXCursor C) { assert(C.kind == CXCursor_TemplateRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorNamespaceRef(const NamedDecl *NS, SourceLocation Loc, CXTranslationUnit TU) { assert(NS && (isa(NS) || isa(NS)) && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_NamespaceRef, 0, { NS, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorNamespaceRef(CXCursor C) { assert(C.kind == CXCursor_NamespaceRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorVariableRef(const VarDecl *Var, SourceLocation Loc, CXTranslationUnit TU) { assert(Var && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_VariableRef, 0, { Var, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorVariableRef(CXCursor C) { assert(C.kind == CXCursor_VariableRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorMemberRef(const FieldDecl *Field, SourceLocation Loc, CXTranslationUnit TU) { assert(Field && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_MemberRef, 0, { Field, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorMemberRef(CXCursor C) { assert(C.kind == CXCursor_MemberRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorCXXBaseSpecifier(const CXXBaseSpecifier *B, CXTranslationUnit TU){ CXCursor C = { CXCursor_CXXBaseSpecifier, 0, { B, nullptr, TU } }; return C; } const CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) { assert(C.kind == CXCursor_CXXBaseSpecifier); return static_cast(C.data[0]); } CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range, CXTranslationUnit TU) { CXCursor C = { CXCursor_PreprocessingDirective, 0, { Range.getBegin().getPtrEncoding(), Range.getEnd().getPtrEncoding(), TU } }; return C; } SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) { assert(C.kind == CXCursor_PreprocessingDirective); SourceRange Range(SourceLocation::getFromPtrEncoding(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); ASTUnit *TU = getCursorASTUnit(C); return TU->mapRangeFromPreamble(Range); } CXCursor cxcursor::MakeMacroDefinitionCursor(const MacroDefinition *MI, CXTranslationUnit TU) { CXCursor C = { CXCursor_MacroDefinition, 0, { MI, nullptr, TU } }; return C; } const MacroDefinition *cxcursor::getCursorMacroDefinition(CXCursor C) { assert(C.kind == CXCursor_MacroDefinition); return static_cast(C.data[0]); } CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI, CXTranslationUnit TU) { CXCursor C = { CXCursor_MacroExpansion, 0, { MI, nullptr, TU } }; return C; } CXCursor cxcursor::MakeMacroExpansionCursor(MacroDefinition *MI, SourceLocation Loc, CXTranslationUnit TU) { assert(Loc.isValid()); CXCursor C = { CXCursor_MacroExpansion, 0, { MI, Loc.getPtrEncoding(), TU } }; return C; } const IdentifierInfo *cxcursor::MacroExpansionCursor::getName() const { if (isPseudo()) return getAsMacroDefinition()->getName(); return getAsMacroExpansion()->getName(); } const MacroDefinition *cxcursor::MacroExpansionCursor::getDefinition() const { if (isPseudo()) return getAsMacroDefinition(); return getAsMacroExpansion()->getDefinition(); } SourceRange cxcursor::MacroExpansionCursor::getSourceRange() const { if (isPseudo()) return getPseudoLoc(); return getAsMacroExpansion()->getSourceRange(); } CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID, CXTranslationUnit TU) { CXCursor C = { CXCursor_InclusionDirective, 0, { ID, nullptr, TU } }; return C; } const InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) { assert(C.kind == CXCursor_InclusionDirective); return static_cast(C.data[0]); } CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc, CXTranslationUnit TU) { assert(Label && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_LabelRef, 0, { Label, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorLabelRef(CXCursor C) { assert(C.kind == CXCursor_LabelRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorOverloadedDeclRef(const OverloadExpr *E, CXTranslationUnit TU) { assert(E && TU && "Invalid arguments!"); OverloadedDeclRefStorage Storage(E); void *RawLoc = E->getNameLoc().getPtrEncoding(); CXCursor C = { CXCursor_OverloadedDeclRef, 0, { Storage.getOpaqueValue(), RawLoc, TU } }; return C; } CXCursor cxcursor::MakeCursorOverloadedDeclRef(const Decl *D, SourceLocation Loc, CXTranslationUnit TU) { assert(D && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); OverloadedDeclRefStorage Storage(D); CXCursor C = { CXCursor_OverloadedDeclRef, 0, { Storage.getOpaqueValue(), RawLoc, TU } }; return C; } CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name, SourceLocation Loc, CXTranslationUnit TU) { assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate()); CXCursor C = { CXCursor_OverloadedDeclRef, 0, { Storage.getOpaqueValue(), RawLoc, TU } }; return C; } std::pair cxcursor::getCursorOverloadedDeclRef(CXCursor C) { assert(C.kind == CXCursor_OverloadedDeclRef); return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue( const_cast(C.data[0])), SourceLocation::getFromPtrEncoding(C.data[1])); } const Decl *cxcursor::getCursorDecl(CXCursor Cursor) { return static_cast(Cursor.data[0]); } const Expr *cxcursor::getCursorExpr(CXCursor Cursor) { return dyn_cast_or_null(getCursorStmt(Cursor)); } const Stmt *cxcursor::getCursorStmt(CXCursor Cursor) { if (Cursor.kind == CXCursor_ObjCSuperClassRef || Cursor.kind == CXCursor_ObjCProtocolRef || Cursor.kind == CXCursor_ObjCClassRef) return nullptr; return static_cast(Cursor.data[1]); } const Attr *cxcursor::getCursorAttr(CXCursor Cursor) { return static_cast(Cursor.data[1]); } const Decl *cxcursor::getCursorParentDecl(CXCursor Cursor) { return static_cast(Cursor.data[0]); } ASTContext &cxcursor::getCursorContext(CXCursor Cursor) { return getCursorASTUnit(Cursor)->getASTContext(); } ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) { CXTranslationUnit TU = getCursorTU(Cursor); if (!TU) return nullptr; return cxtu::getASTUnit(TU); } CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) { return static_cast(const_cast(Cursor.data[2])); } void cxcursor::getOverriddenCursors(CXCursor cursor, SmallVectorImpl &overridden) { assert(clang_isDeclaration(cursor.kind)); const NamedDecl *D = dyn_cast_or_null(getCursorDecl(cursor)); if (!D) return; CXTranslationUnit TU = getCursorTU(cursor); SmallVector OverDecls; D->getASTContext().getOverriddenMethods(D, OverDecls); for (SmallVectorImpl::iterator I = OverDecls.begin(), E = OverDecls.end(); I != E; ++I) { overridden.push_back(MakeCXCursor(*I, TU)); } } std::pair cxcursor::getSelectorIdentifierIndexAndLoc(CXCursor cursor) { if (cursor.kind == CXCursor_ObjCMessageExpr) { if (cursor.xdata != -1) return std::make_pair(cursor.xdata, cast(getCursorExpr(cursor)) ->getSelectorLoc(cursor.xdata)); } else if (cursor.kind == CXCursor_ObjCClassMethodDecl || cursor.kind == CXCursor_ObjCInstanceMethodDecl) { if (cursor.xdata != -1) return std::make_pair(cursor.xdata, cast(getCursorDecl(cursor)) ->getSelectorLoc(cursor.xdata)); } return std::make_pair(-1, SourceLocation()); } CXCursor cxcursor::getSelectorIdentifierCursor(int SelIdx, CXCursor cursor) { CXCursor newCursor = cursor; if (cursor.kind == CXCursor_ObjCMessageExpr) { if (SelIdx == -1 || unsigned(SelIdx) >= cast(getCursorExpr(cursor)) ->getNumSelectorLocs()) newCursor.xdata = -1; else newCursor.xdata = SelIdx; } else if (cursor.kind == CXCursor_ObjCClassMethodDecl || cursor.kind == CXCursor_ObjCInstanceMethodDecl) { if (SelIdx == -1 || unsigned(SelIdx) >= cast(getCursorDecl(cursor)) ->getNumSelectorLocs()) newCursor.xdata = -1; else newCursor.xdata = SelIdx; } return newCursor; } CXCursor cxcursor::getTypeRefCursor(CXCursor cursor) { if (cursor.kind != CXCursor_CallExpr) return cursor; if (cursor.xdata == 0) return cursor; const Expr *E = getCursorExpr(cursor); TypeSourceInfo *Type = nullptr; if (const CXXUnresolvedConstructExpr * UnCtor = dyn_cast(E)) { Type = UnCtor->getTypeSourceInfo(); } else if (const CXXTemporaryObjectExpr *Tmp = dyn_cast(E)){ Type = Tmp->getTypeSourceInfo(); } if (!Type) return cursor; CXTranslationUnit TU = getCursorTU(cursor); QualType Ty = Type->getType(); TypeLoc TL = Type->getTypeLoc(); SourceLocation Loc = TL.getBeginLoc(); if (const ElaboratedType *ElabT = Ty->getAs()) { Ty = ElabT->getNamedType(); ElaboratedTypeLoc ElabTL = TL.castAs(); Loc = ElabTL.getNamedTypeLoc().getBeginLoc(); } if (const TypedefType *Typedef = Ty->getAs()) return MakeCursorTypeRef(Typedef->getDecl(), Loc, TU); if (const TagType *Tag = Ty->getAs()) return MakeCursorTypeRef(Tag->getDecl(), Loc, TU); if (const TemplateTypeParmType *TemplP = Ty->getAs()) return MakeCursorTypeRef(TemplP->getDecl(), Loc, TU); return cursor; } bool cxcursor::operator==(CXCursor X, CXCursor Y) { return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] && X.data[2] == Y.data[2]; } // FIXME: Remove once we can model DeclGroups and their appropriate ranges // properly in the ASTs. bool cxcursor::isFirstInDeclGroup(CXCursor C) { assert(clang_isDeclaration(C.kind)); return ((uintptr_t) (C.data[1])) != 0; } //===----------------------------------------------------------------------===// // libclang CXCursor APIs //===----------------------------------------------------------------------===// extern "C" { int clang_Cursor_isNull(CXCursor cursor) { return clang_equalCursors(cursor, clang_getNullCursor()); } CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) { return getCursorTU(cursor); } int clang_Cursor_getNumArguments(CXCursor C) { if (clang_isDeclaration(C.kind)) { const Decl *D = cxcursor::getCursorDecl(C); if (const ObjCMethodDecl *MD = dyn_cast_or_null(D)) return MD->param_size(); if (const FunctionDecl *FD = dyn_cast_or_null(D)) return FD->param_size(); } if (clang_isExpression(C.kind)) { const Expr *E = cxcursor::getCursorExpr(C); if (const CallExpr *CE = dyn_cast(E)) { return CE->getNumArgs(); } } return -1; } CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i) { if (clang_isDeclaration(C.kind)) { const Decl *D = cxcursor::getCursorDecl(C); if (const ObjCMethodDecl *MD = dyn_cast_or_null(D)) { if (i < MD->param_size()) return cxcursor::MakeCXCursor(MD->parameters()[i], cxcursor::getCursorTU(C)); } else if (const FunctionDecl *FD = dyn_cast_or_null(D)) { if (i < FD->param_size()) return cxcursor::MakeCXCursor(FD->parameters()[i], cxcursor::getCursorTU(C)); } } if (clang_isExpression(C.kind)) { const Expr *E = cxcursor::getCursorExpr(C); if (const CallExpr *CE = dyn_cast(E)) { if (i < CE->getNumArgs()) { return cxcursor::MakeCXCursor(CE->getArg(i), getCursorDecl(C), cxcursor::getCursorTU(C)); } } } return clang_getNullCursor(); } } // end: extern "C" //===----------------------------------------------------------------------===// // CXCursorSet. //===----------------------------------------------------------------------===// typedef llvm::DenseMap CXCursorSet_Impl; static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) { return (CXCursorSet) setImpl; } static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) { return (CXCursorSet_Impl*) set; } namespace llvm { template<> struct DenseMapInfo { public: static inline CXCursor getEmptyKey() { return MakeCXCursorInvalid(CXCursor_InvalidFile); } static inline CXCursor getTombstoneKey() { return MakeCXCursorInvalid(CXCursor_NoDeclFound); } static inline unsigned getHashValue(const CXCursor &cursor) { return llvm::DenseMapInfo > ::getHashValue(std::make_pair(cursor.data[0], cursor.data[1])); } static inline bool isEqual(const CXCursor &x, const CXCursor &y) { return x.kind == y.kind && x.data[0] == y.data[0] && x.data[1] == y.data[1]; } }; } extern "C" { CXCursorSet clang_createCXCursorSet() { return packCXCursorSet(new CXCursorSet_Impl()); } void clang_disposeCXCursorSet(CXCursorSet set) { delete unpackCXCursorSet(set); } unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) { CXCursorSet_Impl *setImpl = unpackCXCursorSet(set); if (!setImpl) return 0; return setImpl->find(cursor) != setImpl->end(); } unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) { // Do not insert invalid cursors into the set. if (cursor.kind >= CXCursor_FirstInvalid && cursor.kind <= CXCursor_LastInvalid) return 1; CXCursorSet_Impl *setImpl = unpackCXCursorSet(set); if (!setImpl) return 1; unsigned &entry = (*setImpl)[cursor]; unsigned flag = entry == 0 ? 1 : 0; entry = 1; return flag; } CXCompletionString clang_getCursorCompletionString(CXCursor cursor) { enum CXCursorKind kind = clang_getCursorKind(cursor); if (clang_isDeclaration(kind)) { const Decl *decl = getCursorDecl(cursor); if (const NamedDecl *namedDecl = dyn_cast_or_null(decl)) { ASTUnit *unit = getCursorASTUnit(cursor); CodeCompletionResult Result(namedDecl, CCP_Declaration); CodeCompletionString *String = Result.CreateCodeCompletionString(unit->getASTContext(), unit->getPreprocessor(), unit->getCodeCompletionTUInfo().getAllocator(), unit->getCodeCompletionTUInfo(), true); return String; } } else if (kind == CXCursor_MacroDefinition) { const MacroDefinition *definition = getCursorMacroDefinition(cursor); const IdentifierInfo *MacroInfo = definition->getName(); ASTUnit *unit = getCursorASTUnit(cursor); CodeCompletionResult Result(MacroInfo); CodeCompletionString *String = Result.CreateCodeCompletionString(unit->getASTContext(), unit->getPreprocessor(), unit->getCodeCompletionTUInfo().getAllocator(), unit->getCodeCompletionTUInfo(), false); return String; } return nullptr; } } // end: extern C. namespace { struct OverridenCursorsPool { typedef SmallVector CursorVec; std::vector AllCursors; std::vector AvailableCursors; ~OverridenCursorsPool() { for (std::vector::iterator I = AllCursors.begin(), E = AllCursors.end(); I != E; ++I) { delete *I; } } }; } void *cxcursor::createOverridenCXCursorsPool() { return new OverridenCursorsPool(); } void cxcursor::disposeOverridenCXCursorsPool(void *pool) { delete static_cast(pool); } extern "C" { void clang_getOverriddenCursors(CXCursor cursor, CXCursor **overridden, unsigned *num_overridden) { if (overridden) *overridden = nullptr; if (num_overridden) *num_overridden = 0; CXTranslationUnit TU = cxcursor::getCursorTU(cursor); if (!overridden || !num_overridden || !TU) return; if (!clang_isDeclaration(cursor.kind)) return; OverridenCursorsPool &pool = *static_cast(TU->OverridenCursorsPool); OverridenCursorsPool::CursorVec *Vec = nullptr; if (!pool.AvailableCursors.empty()) { Vec = pool.AvailableCursors.back(); pool.AvailableCursors.pop_back(); } else { Vec = new OverridenCursorsPool::CursorVec(); pool.AllCursors.push_back(Vec); } // Clear out the vector, but don't free the memory contents. This // reduces malloc() traffic. Vec->clear(); // Use the first entry to contain a back reference to the vector. // This is a complete hack. CXCursor backRefCursor = MakeCXCursorInvalid(CXCursor_InvalidFile, TU); backRefCursor.data[0] = Vec; assert(cxcursor::getCursorTU(backRefCursor) == TU); Vec->push_back(backRefCursor); // Get the overriden cursors. cxcursor::getOverriddenCursors(cursor, *Vec); // Did we get any overriden cursors? If not, return Vec to the pool // of available cursor vectors. if (Vec->size() == 1) { pool.AvailableCursors.push_back(Vec); return; } // Now tell the caller about the overriden cursors. assert(Vec->size() > 1); *overridden = &((*Vec)[1]); *num_overridden = Vec->size() - 1; } void clang_disposeOverriddenCursors(CXCursor *overridden) { if (!overridden) return; // Use pointer arithmetic to get back the first faux entry // which has a back-reference to the TU and the vector. --overridden; OverridenCursorsPool::CursorVec *Vec = static_cast( const_cast(overridden->data[0])); CXTranslationUnit TU = getCursorTU(*overridden); assert(Vec && TU); OverridenCursorsPool &pool = *static_cast(TU->OverridenCursorsPool); pool.AvailableCursors.push_back(Vec); } int clang_Cursor_isDynamicCall(CXCursor C) { const Expr *E = nullptr; if (clang_isExpression(C.kind)) E = getCursorExpr(C); if (!E) return 0; if (const ObjCMessageExpr *MsgE = dyn_cast(E)) return MsgE->getReceiverKind() == ObjCMessageExpr::Instance; const MemberExpr *ME = nullptr; if (isa(E)) ME = cast(E); else if (const CallExpr *CE = dyn_cast(E)) ME = dyn_cast_or_null(CE->getCallee()); if (ME) { if (const CXXMethodDecl * MD = dyn_cast_or_null(ME->getMemberDecl())) return MD->isVirtual() && !ME->hasQualifier(); } return 0; } CXType clang_Cursor_getReceiverType(CXCursor C) { CXTranslationUnit TU = cxcursor::getCursorTU(C); const Expr *E = nullptr; if (clang_isExpression(C.kind)) E = getCursorExpr(C); if (const ObjCMessageExpr *MsgE = dyn_cast_or_null(E)) return cxtype::MakeCXType(MsgE->getReceiverType(), TU); return cxtype::MakeCXType(QualType(), TU); } } // end: extern "C" @ 1.1.1.3.4.1 log @file CXCursor.cpp was added on branch yamt-pagecache on 2014-05-22 16:19:47 +0000 @ text @d1 1245 @ 1.1.1.3.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 1245 //===- CXCursor.cpp - Routines for manipulating CXCursors -----------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines routines for manipulating CXCursors. It should be the // only file that has internal knowledge of the encoding of the data in // CXCursor. // //===----------------------------------------------------------------------===// #include "CXTranslationUnit.h" #include "CXCursor.h" #include "CXString.h" #include "CXType.h" #include "clang-c/Index.h" #include "clang/AST/Attr.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/ExprObjC.h" #include "clang/Frontend/ASTUnit.h" #include "llvm/Support/ErrorHandling.h" using namespace clang; using namespace cxcursor; CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K, CXTranslationUnit TU) { assert(K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid); CXCursor C = { K, 0, { 0, 0, TU } }; return C; } static CXCursorKind GetCursorKind(const Attr *A) { assert(A && "Invalid arguments!"); switch (A->getKind()) { default: break; case attr::IBAction: return CXCursor_IBActionAttr; case attr::IBOutlet: return CXCursor_IBOutletAttr; case attr::IBOutletCollection: return CXCursor_IBOutletCollectionAttr; case attr::Final: return CXCursor_CXXFinalAttr; case attr::Override: return CXCursor_CXXOverrideAttr; case attr::Annotate: return CXCursor_AnnotateAttr; case attr::AsmLabel: return CXCursor_AsmLabelAttr; case attr::Packed: return CXCursor_PackedAttr; } return CXCursor_UnexposedAttr; } CXCursor cxcursor::MakeCXCursor(const Attr *A, const Decl *Parent, CXTranslationUnit TU) { assert(A && Parent && TU && "Invalid arguments!"); CXCursor C = { GetCursorKind(A), 0, { Parent, A, TU } }; return C; } CXCursor cxcursor::MakeCXCursor(const Decl *D, CXTranslationUnit TU, SourceRange RegionOfInterest, bool FirstInDeclGroup) { assert(D && TU && "Invalid arguments!"); CXCursorKind K = getCursorKindForDecl(D); if (K == CXCursor_ObjCClassMethodDecl || K == CXCursor_ObjCInstanceMethodDecl) { int SelectorIdIndex = -1; // Check if cursor points to a selector id. if (RegionOfInterest.isValid() && RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) { SmallVector SelLocs; cast(D)->getSelectorLocs(SelLocs); SmallVectorImpl::iterator I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin()); if (I != SelLocs.end()) SelectorIdIndex = I - SelLocs.begin(); } CXCursor C = { K, SelectorIdIndex, { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }}; return C; } CXCursor C = { K, 0, { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }}; return C; } CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent, CXTranslationUnit TU, SourceRange RegionOfInterest) { assert(S && TU && "Invalid arguments!"); CXCursorKind K = CXCursor_NotImplemented; switch (S->getStmtClass()) { case Stmt::NoStmtClass: break; case Stmt::CaseStmtClass: K = CXCursor_CaseStmt; break; case Stmt::DefaultStmtClass: K = CXCursor_DefaultStmt; break; case Stmt::IfStmtClass: K = CXCursor_IfStmt; break; case Stmt::SwitchStmtClass: K = CXCursor_SwitchStmt; break; case Stmt::WhileStmtClass: K = CXCursor_WhileStmt; break; case Stmt::DoStmtClass: K = CXCursor_DoStmt; break; case Stmt::ForStmtClass: K = CXCursor_ForStmt; break; case Stmt::GotoStmtClass: K = CXCursor_GotoStmt; break; case Stmt::IndirectGotoStmtClass: K = CXCursor_IndirectGotoStmt; break; case Stmt::ContinueStmtClass: K = CXCursor_ContinueStmt; break; case Stmt::BreakStmtClass: K = CXCursor_BreakStmt; break; case Stmt::ReturnStmtClass: K = CXCursor_ReturnStmt; break; case Stmt::GCCAsmStmtClass: K = CXCursor_GCCAsmStmt; break; case Stmt::MSAsmStmtClass: K = CXCursor_MSAsmStmt; break; case Stmt::ObjCAtTryStmtClass: K = CXCursor_ObjCAtTryStmt; break; case Stmt::ObjCAtCatchStmtClass: K = CXCursor_ObjCAtCatchStmt; break; case Stmt::ObjCAtFinallyStmtClass: K = CXCursor_ObjCAtFinallyStmt; break; case Stmt::ObjCAtThrowStmtClass: K = CXCursor_ObjCAtThrowStmt; break; case Stmt::ObjCAtSynchronizedStmtClass: K = CXCursor_ObjCAtSynchronizedStmt; break; case Stmt::ObjCAutoreleasePoolStmtClass: K = CXCursor_ObjCAutoreleasePoolStmt; break; case Stmt::ObjCForCollectionStmtClass: K = CXCursor_ObjCForCollectionStmt; break; case Stmt::CXXCatchStmtClass: K = CXCursor_CXXCatchStmt; break; case Stmt::CXXTryStmtClass: K = CXCursor_CXXTryStmt; break; case Stmt::CXXForRangeStmtClass: K = CXCursor_CXXForRangeStmt; break; case Stmt::SEHTryStmtClass: K = CXCursor_SEHTryStmt; break; case Stmt::SEHExceptStmtClass: K = CXCursor_SEHExceptStmt; break; case Stmt::SEHFinallyStmtClass: K = CXCursor_SEHFinallyStmt; break; case Stmt::ArrayTypeTraitExprClass: case Stmt::AsTypeExprClass: case Stmt::AtomicExprClass: case Stmt::BinaryConditionalOperatorClass: case Stmt::TypeTraitExprClass: case Stmt::CXXBindTemporaryExprClass: case Stmt::CXXDefaultArgExprClass: case Stmt::CXXDefaultInitExprClass: case Stmt::CXXStdInitializerListExprClass: case Stmt::CXXScalarValueInitExprClass: case Stmt::CXXUuidofExprClass: case Stmt::ChooseExprClass: case Stmt::DesignatedInitExprClass: case Stmt::ExprWithCleanupsClass: case Stmt::ExpressionTraitExprClass: case Stmt::ExtVectorElementExprClass: case Stmt::ImplicitCastExprClass: case Stmt::ImplicitValueInitExprClass: case Stmt::MaterializeTemporaryExprClass: case Stmt::ObjCIndirectCopyRestoreExprClass: case Stmt::OffsetOfExprClass: case Stmt::ParenListExprClass: case Stmt::PredefinedExprClass: case Stmt::ShuffleVectorExprClass: case Stmt::ConvertVectorExprClass: case Stmt::UnaryExprOrTypeTraitExprClass: case Stmt::VAArgExprClass: case Stmt::ObjCArrayLiteralClass: case Stmt::ObjCDictionaryLiteralClass: case Stmt::ObjCBoxedExprClass: case Stmt::ObjCSubscriptRefExprClass: K = CXCursor_UnexposedExpr; break; case Stmt::OpaqueValueExprClass: if (Expr *Src = cast(S)->getSourceExpr()) return MakeCXCursor(Src, Parent, TU, RegionOfInterest); K = CXCursor_UnexposedExpr; break; case Stmt::PseudoObjectExprClass: return MakeCXCursor(cast(S)->getSyntacticForm(), Parent, TU, RegionOfInterest); case Stmt::CompoundStmtClass: K = CXCursor_CompoundStmt; break; case Stmt::NullStmtClass: K = CXCursor_NullStmt; break; case Stmt::LabelStmtClass: K = CXCursor_LabelStmt; break; case Stmt::AttributedStmtClass: K = CXCursor_UnexposedStmt; break; case Stmt::DeclStmtClass: K = CXCursor_DeclStmt; break; case Stmt::CapturedStmtClass: K = CXCursor_UnexposedStmt; break; case Stmt::IntegerLiteralClass: K = CXCursor_IntegerLiteral; break; case Stmt::FloatingLiteralClass: K = CXCursor_FloatingLiteral; break; case Stmt::ImaginaryLiteralClass: K = CXCursor_ImaginaryLiteral; break; case Stmt::StringLiteralClass: K = CXCursor_StringLiteral; break; case Stmt::CharacterLiteralClass: K = CXCursor_CharacterLiteral; break; case Stmt::ParenExprClass: K = CXCursor_ParenExpr; break; case Stmt::UnaryOperatorClass: K = CXCursor_UnaryOperator; break; case Stmt::CXXNoexceptExprClass: K = CXCursor_UnaryExpr; break; case Stmt::ArraySubscriptExprClass: K = CXCursor_ArraySubscriptExpr; break; case Stmt::BinaryOperatorClass: K = CXCursor_BinaryOperator; break; case Stmt::CompoundAssignOperatorClass: K = CXCursor_CompoundAssignOperator; break; case Stmt::ConditionalOperatorClass: K = CXCursor_ConditionalOperator; break; case Stmt::CStyleCastExprClass: K = CXCursor_CStyleCastExpr; break; case Stmt::CompoundLiteralExprClass: K = CXCursor_CompoundLiteralExpr; break; case Stmt::InitListExprClass: K = CXCursor_InitListExpr; break; case Stmt::AddrLabelExprClass: K = CXCursor_AddrLabelExpr; break; case Stmt::StmtExprClass: K = CXCursor_StmtExpr; break; case Stmt::GenericSelectionExprClass: K = CXCursor_GenericSelectionExpr; break; case Stmt::GNUNullExprClass: K = CXCursor_GNUNullExpr; break; case Stmt::CXXStaticCastExprClass: K = CXCursor_CXXStaticCastExpr; break; case Stmt::CXXDynamicCastExprClass: K = CXCursor_CXXDynamicCastExpr; break; case Stmt::CXXReinterpretCastExprClass: K = CXCursor_CXXReinterpretCastExpr; break; case Stmt::CXXConstCastExprClass: K = CXCursor_CXXConstCastExpr; break; case Stmt::CXXFunctionalCastExprClass: K = CXCursor_CXXFunctionalCastExpr; break; case Stmt::CXXTypeidExprClass: K = CXCursor_CXXTypeidExpr; break; case Stmt::CXXBoolLiteralExprClass: K = CXCursor_CXXBoolLiteralExpr; break; case Stmt::CXXNullPtrLiteralExprClass: K = CXCursor_CXXNullPtrLiteralExpr; break; case Stmt::CXXThisExprClass: K = CXCursor_CXXThisExpr; break; case Stmt::CXXThrowExprClass: K = CXCursor_CXXThrowExpr; break; case Stmt::CXXNewExprClass: K = CXCursor_CXXNewExpr; break; case Stmt::CXXDeleteExprClass: K = CXCursor_CXXDeleteExpr; break; case Stmt::ObjCStringLiteralClass: K = CXCursor_ObjCStringLiteral; break; case Stmt::ObjCEncodeExprClass: K = CXCursor_ObjCEncodeExpr; break; case Stmt::ObjCSelectorExprClass: K = CXCursor_ObjCSelectorExpr; break; case Stmt::ObjCProtocolExprClass: K = CXCursor_ObjCProtocolExpr; break; case Stmt::ObjCBoolLiteralExprClass: K = CXCursor_ObjCBoolLiteralExpr; break; case Stmt::ObjCBridgedCastExprClass: K = CXCursor_ObjCBridgedCastExpr; break; case Stmt::BlockExprClass: K = CXCursor_BlockExpr; break; case Stmt::PackExpansionExprClass: K = CXCursor_PackExpansionExpr; break; case Stmt::SizeOfPackExprClass: K = CXCursor_SizeOfPackExpr; break; case Stmt::DeclRefExprClass: if (const ImplicitParamDecl *IPD = dyn_cast_or_null(cast(S)->getDecl())) { if (const ObjCMethodDecl *MD = dyn_cast(IPD->getDeclContext())) { if (MD->getSelfDecl() == IPD) { K = CXCursor_ObjCSelfExpr; break; } } } K = CXCursor_DeclRefExpr; break; case Stmt::DependentScopeDeclRefExprClass: case Stmt::SubstNonTypeTemplateParmExprClass: case Stmt::SubstNonTypeTemplateParmPackExprClass: case Stmt::FunctionParmPackExprClass: case Stmt::UnresolvedLookupExprClass: K = CXCursor_DeclRefExpr; break; case Stmt::CXXDependentScopeMemberExprClass: case Stmt::CXXPseudoDestructorExprClass: case Stmt::MemberExprClass: case Stmt::MSPropertyRefExprClass: case Stmt::ObjCIsaExprClass: case Stmt::ObjCIvarRefExprClass: case Stmt::ObjCPropertyRefExprClass: case Stmt::UnresolvedMemberExprClass: K = CXCursor_MemberRefExpr; break; case Stmt::CallExprClass: case Stmt::CXXOperatorCallExprClass: case Stmt::CXXMemberCallExprClass: case Stmt::CUDAKernelCallExprClass: case Stmt::CXXConstructExprClass: case Stmt::CXXTemporaryObjectExprClass: case Stmt::CXXUnresolvedConstructExprClass: case Stmt::UserDefinedLiteralClass: K = CXCursor_CallExpr; break; case Stmt::LambdaExprClass: K = CXCursor_LambdaExpr; break; case Stmt::ObjCMessageExprClass: { K = CXCursor_ObjCMessageExpr; int SelectorIdIndex = -1; // Check if cursor points to a selector id. if (RegionOfInterest.isValid() && RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) { SmallVector SelLocs; cast(S)->getSelectorLocs(SelLocs); SmallVectorImpl::iterator I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin()); if (I != SelLocs.end()) SelectorIdIndex = I - SelLocs.begin(); } CXCursor C = { K, 0, { Parent, S, TU } }; return getSelectorIdentifierCursor(SelectorIdIndex, C); } case Stmt::MSDependentExistsStmtClass: K = CXCursor_UnexposedStmt; break; case Stmt::OMPParallelDirectiveClass: K = CXCursor_OMPParallelDirective; break; case Stmt::OMPSimdDirectiveClass: K = CXCursor_OMPSimdDirective; break; } CXCursor C = { K, 0, { Parent, S, TU } }; return C; } CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super, SourceLocation Loc, CXTranslationUnit TU) { assert(Super && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_ObjCSuperClassRef, 0, { Super, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorObjCSuperClassRef(CXCursor C) { assert(C.kind == CXCursor_ObjCSuperClassRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorObjCProtocolRef(const ObjCProtocolDecl *Proto, SourceLocation Loc, CXTranslationUnit TU) { assert(Proto && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_ObjCProtocolRef, 0, { Proto, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorObjCProtocolRef(CXCursor C) { assert(C.kind == CXCursor_ObjCProtocolRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorObjCClassRef(const ObjCInterfaceDecl *Class, SourceLocation Loc, CXTranslationUnit TU) { // 'Class' can be null for invalid code. if (!Class) return MakeCXCursorInvalid(CXCursor_InvalidCode); assert(TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_ObjCClassRef, 0, { Class, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorObjCClassRef(CXCursor C) { assert(C.kind == CXCursor_ObjCClassRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorTypeRef(const TypeDecl *Type, SourceLocation Loc, CXTranslationUnit TU) { assert(Type && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_TypeRef, 0, { Type, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorTypeRef(CXCursor C) { assert(C.kind == CXCursor_TypeRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorTemplateRef(const TemplateDecl *Template, SourceLocation Loc, CXTranslationUnit TU) { assert(Template && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_TemplateRef, 0, { Template, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorTemplateRef(CXCursor C) { assert(C.kind == CXCursor_TemplateRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorNamespaceRef(const NamedDecl *NS, SourceLocation Loc, CXTranslationUnit TU) { assert(NS && (isa(NS) || isa(NS)) && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_NamespaceRef, 0, { NS, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorNamespaceRef(CXCursor C) { assert(C.kind == CXCursor_NamespaceRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorVariableRef(const VarDecl *Var, SourceLocation Loc, CXTranslationUnit TU) { assert(Var && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_VariableRef, 0, { Var, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorVariableRef(CXCursor C) { assert(C.kind == CXCursor_VariableRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorMemberRef(const FieldDecl *Field, SourceLocation Loc, CXTranslationUnit TU) { assert(Field && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_MemberRef, 0, { Field, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorMemberRef(CXCursor C) { assert(C.kind == CXCursor_MemberRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorCXXBaseSpecifier(const CXXBaseSpecifier *B, CXTranslationUnit TU){ CXCursor C = { CXCursor_CXXBaseSpecifier, 0, { B, 0, TU } }; return C; } const CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) { assert(C.kind == CXCursor_CXXBaseSpecifier); return static_cast(C.data[0]); } CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range, CXTranslationUnit TU) { CXCursor C = { CXCursor_PreprocessingDirective, 0, { Range.getBegin().getPtrEncoding(), Range.getEnd().getPtrEncoding(), TU } }; return C; } SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) { assert(C.kind == CXCursor_PreprocessingDirective); SourceRange Range(SourceLocation::getFromPtrEncoding(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); ASTUnit *TU = getCursorASTUnit(C); return TU->mapRangeFromPreamble(Range); } CXCursor cxcursor::MakeMacroDefinitionCursor(const MacroDefinition *MI, CXTranslationUnit TU) { CXCursor C = { CXCursor_MacroDefinition, 0, { MI, 0, TU } }; return C; } const MacroDefinition *cxcursor::getCursorMacroDefinition(CXCursor C) { assert(C.kind == CXCursor_MacroDefinition); return static_cast(C.data[0]); } CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI, CXTranslationUnit TU) { CXCursor C = { CXCursor_MacroExpansion, 0, { MI, 0, TU } }; return C; } CXCursor cxcursor::MakeMacroExpansionCursor(MacroDefinition *MI, SourceLocation Loc, CXTranslationUnit TU) { assert(Loc.isValid()); CXCursor C = { CXCursor_MacroExpansion, 0, { MI, Loc.getPtrEncoding(), TU } }; return C; } const IdentifierInfo *cxcursor::MacroExpansionCursor::getName() const { if (isPseudo()) return getAsMacroDefinition()->getName(); return getAsMacroExpansion()->getName(); } const MacroDefinition *cxcursor::MacroExpansionCursor::getDefinition() const { if (isPseudo()) return getAsMacroDefinition(); return getAsMacroExpansion()->getDefinition(); } SourceRange cxcursor::MacroExpansionCursor::getSourceRange() const { if (isPseudo()) return getPseudoLoc(); return getAsMacroExpansion()->getSourceRange(); } CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID, CXTranslationUnit TU) { CXCursor C = { CXCursor_InclusionDirective, 0, { ID, 0, TU } }; return C; } const InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) { assert(C.kind == CXCursor_InclusionDirective); return static_cast(C.data[0]); } CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc, CXTranslationUnit TU) { assert(Label && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); CXCursor C = { CXCursor_LabelRef, 0, { Label, RawLoc, TU } }; return C; } std::pair cxcursor::getCursorLabelRef(CXCursor C) { assert(C.kind == CXCursor_LabelRef); return std::make_pair(static_cast(C.data[0]), SourceLocation::getFromPtrEncoding(C.data[1])); } CXCursor cxcursor::MakeCursorOverloadedDeclRef(const OverloadExpr *E, CXTranslationUnit TU) { assert(E && TU && "Invalid arguments!"); OverloadedDeclRefStorage Storage(E); void *RawLoc = E->getNameLoc().getPtrEncoding(); CXCursor C = { CXCursor_OverloadedDeclRef, 0, { Storage.getOpaqueValue(), RawLoc, TU } }; return C; } CXCursor cxcursor::MakeCursorOverloadedDeclRef(const Decl *D, SourceLocation Loc, CXTranslationUnit TU) { assert(D && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); OverloadedDeclRefStorage Storage(D); CXCursor C = { CXCursor_OverloadedDeclRef, 0, { Storage.getOpaqueValue(), RawLoc, TU } }; return C; } CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name, SourceLocation Loc, CXTranslationUnit TU) { assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!"); void *RawLoc = Loc.getPtrEncoding(); OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate()); CXCursor C = { CXCursor_OverloadedDeclRef, 0, { Storage.getOpaqueValue(), RawLoc, TU } }; return C; } std::pair cxcursor::getCursorOverloadedDeclRef(CXCursor C) { assert(C.kind == CXCursor_OverloadedDeclRef); return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue( const_cast(C.data[0])), SourceLocation::getFromPtrEncoding(C.data[1])); } const Decl *cxcursor::getCursorDecl(CXCursor Cursor) { return static_cast(Cursor.data[0]); } const Expr *cxcursor::getCursorExpr(CXCursor Cursor) { return dyn_cast_or_null(getCursorStmt(Cursor)); } const Stmt *cxcursor::getCursorStmt(CXCursor Cursor) { if (Cursor.kind == CXCursor_ObjCSuperClassRef || Cursor.kind == CXCursor_ObjCProtocolRef || Cursor.kind == CXCursor_ObjCClassRef) return 0; return static_cast(Cursor.data[1]); } const Attr *cxcursor::getCursorAttr(CXCursor Cursor) { return static_cast(Cursor.data[1]); } const Decl *cxcursor::getCursorParentDecl(CXCursor Cursor) { return static_cast(Cursor.data[0]); } ASTContext &cxcursor::getCursorContext(CXCursor Cursor) { return getCursorASTUnit(Cursor)->getASTContext(); } ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) { CXTranslationUnit TU = getCursorTU(Cursor); if (!TU) return 0; return cxtu::getASTUnit(TU); } CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) { return static_cast(const_cast(Cursor.data[2])); } void cxcursor::getOverriddenCursors(CXCursor cursor, SmallVectorImpl &overridden) { assert(clang_isDeclaration(cursor.kind)); const NamedDecl *D = dyn_cast_or_null(getCursorDecl(cursor)); if (!D) return; CXTranslationUnit TU = getCursorTU(cursor); SmallVector OverDecls; D->getASTContext().getOverriddenMethods(D, OverDecls); for (SmallVectorImpl::iterator I = OverDecls.begin(), E = OverDecls.end(); I != E; ++I) { overridden.push_back(MakeCXCursor(*I, TU)); } } std::pair cxcursor::getSelectorIdentifierIndexAndLoc(CXCursor cursor) { if (cursor.kind == CXCursor_ObjCMessageExpr) { if (cursor.xdata != -1) return std::make_pair(cursor.xdata, cast(getCursorExpr(cursor)) ->getSelectorLoc(cursor.xdata)); } else if (cursor.kind == CXCursor_ObjCClassMethodDecl || cursor.kind == CXCursor_ObjCInstanceMethodDecl) { if (cursor.xdata != -1) return std::make_pair(cursor.xdata, cast(getCursorDecl(cursor)) ->getSelectorLoc(cursor.xdata)); } return std::make_pair(-1, SourceLocation()); } CXCursor cxcursor::getSelectorIdentifierCursor(int SelIdx, CXCursor cursor) { CXCursor newCursor = cursor; if (cursor.kind == CXCursor_ObjCMessageExpr) { if (SelIdx == -1 || unsigned(SelIdx) >= cast(getCursorExpr(cursor)) ->getNumSelectorLocs()) newCursor.xdata = -1; else newCursor.xdata = SelIdx; } else if (cursor.kind == CXCursor_ObjCClassMethodDecl || cursor.kind == CXCursor_ObjCInstanceMethodDecl) { if (SelIdx == -1 || unsigned(SelIdx) >= cast(getCursorDecl(cursor)) ->getNumSelectorLocs()) newCursor.xdata = -1; else newCursor.xdata = SelIdx; } return newCursor; } CXCursor cxcursor::getTypeRefCursor(CXCursor cursor) { if (cursor.kind != CXCursor_CallExpr) return cursor; if (cursor.xdata == 0) return cursor; const Expr *E = getCursorExpr(cursor); TypeSourceInfo *Type = 0; if (const CXXUnresolvedConstructExpr * UnCtor = dyn_cast(E)) { Type = UnCtor->getTypeSourceInfo(); } else if (const CXXTemporaryObjectExpr *Tmp = dyn_cast(E)){ Type = Tmp->getTypeSourceInfo(); } if (!Type) return cursor; CXTranslationUnit TU = getCursorTU(cursor); QualType Ty = Type->getType(); TypeLoc TL = Type->getTypeLoc(); SourceLocation Loc = TL.getBeginLoc(); if (const ElaboratedType *ElabT = Ty->getAs()) { Ty = ElabT->getNamedType(); ElaboratedTypeLoc ElabTL = TL.castAs(); Loc = ElabTL.getNamedTypeLoc().getBeginLoc(); } if (const TypedefType *Typedef = Ty->getAs()) return MakeCursorTypeRef(Typedef->getDecl(), Loc, TU); if (const TagType *Tag = Ty->getAs()) return MakeCursorTypeRef(Tag->getDecl(), Loc, TU); if (const TemplateTypeParmType *TemplP = Ty->getAs()) return MakeCursorTypeRef(TemplP->getDecl(), Loc, TU); return cursor; } bool cxcursor::operator==(CXCursor X, CXCursor Y) { return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] && X.data[2] == Y.data[2]; } // FIXME: Remove once we can model DeclGroups and their appropriate ranges // properly in the ASTs. bool cxcursor::isFirstInDeclGroup(CXCursor C) { assert(clang_isDeclaration(C.kind)); return ((uintptr_t) (C.data[1])) != 0; } //===----------------------------------------------------------------------===// // libclang CXCursor APIs //===----------------------------------------------------------------------===// extern "C" { int clang_Cursor_isNull(CXCursor cursor) { return clang_equalCursors(cursor, clang_getNullCursor()); } CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) { return getCursorTU(cursor); } int clang_Cursor_getNumArguments(CXCursor C) { if (clang_isDeclaration(C.kind)) { const Decl *D = cxcursor::getCursorDecl(C); if (const ObjCMethodDecl *MD = dyn_cast_or_null(D)) return MD->param_size(); if (const FunctionDecl *FD = dyn_cast_or_null(D)) return FD->param_size(); } if (clang_isExpression(C.kind)) { const Expr *E = cxcursor::getCursorExpr(C); if (const CallExpr *CE = dyn_cast(E)) { return CE->getNumArgs(); } } return -1; } CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i) { if (clang_isDeclaration(C.kind)) { const Decl *D = cxcursor::getCursorDecl(C); if (const ObjCMethodDecl *MD = dyn_cast_or_null(D)) { if (i < MD->param_size()) return cxcursor::MakeCXCursor(MD->param_begin()[i], cxcursor::getCursorTU(C)); } else if (const FunctionDecl *FD = dyn_cast_or_null(D)) { if (i < FD->param_size()) return cxcursor::MakeCXCursor(FD->param_begin()[i], cxcursor::getCursorTU(C)); } } if (clang_isExpression(C.kind)) { const Expr *E = cxcursor::getCursorExpr(C); if (const CallExpr *CE = dyn_cast(E)) { if (i < CE->getNumArgs()) { return cxcursor::MakeCXCursor(CE->getArg(i), getCursorDecl(C), cxcursor::getCursorTU(C)); } } } return clang_getNullCursor(); } } // end: extern "C" //===----------------------------------------------------------------------===// // CXCursorSet. //===----------------------------------------------------------------------===// typedef llvm::DenseMap CXCursorSet_Impl; static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) { return (CXCursorSet) setImpl; } static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) { return (CXCursorSet_Impl*) set; } namespace llvm { template<> struct DenseMapInfo { public: static inline CXCursor getEmptyKey() { return MakeCXCursorInvalid(CXCursor_InvalidFile); } static inline CXCursor getTombstoneKey() { return MakeCXCursorInvalid(CXCursor_NoDeclFound); } static inline unsigned getHashValue(const CXCursor &cursor) { return llvm::DenseMapInfo > ::getHashValue(std::make_pair(cursor.data[0], cursor.data[1])); } static inline bool isEqual(const CXCursor &x, const CXCursor &y) { return x.kind == y.kind && x.data[0] == y.data[0] && x.data[1] == y.data[1]; } }; } extern "C" { CXCursorSet clang_createCXCursorSet() { return packCXCursorSet(new CXCursorSet_Impl()); } void clang_disposeCXCursorSet(CXCursorSet set) { delete unpackCXCursorSet(set); } unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) { CXCursorSet_Impl *setImpl = unpackCXCursorSet(set); if (!setImpl) return 0; return setImpl->find(cursor) != setImpl->end(); } unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) { // Do not insert invalid cursors into the set. if (cursor.kind >= CXCursor_FirstInvalid && cursor.kind <= CXCursor_LastInvalid) return 1; CXCursorSet_Impl *setImpl = unpackCXCursorSet(set); if (!setImpl) return 1; unsigned &entry = (*setImpl)[cursor]; unsigned flag = entry == 0 ? 1 : 0; entry = 1; return flag; } CXCompletionString clang_getCursorCompletionString(CXCursor cursor) { enum CXCursorKind kind = clang_getCursorKind(cursor); if (clang_isDeclaration(kind)) { const Decl *decl = getCursorDecl(cursor); if (const NamedDecl *namedDecl = dyn_cast_or_null(decl)) { ASTUnit *unit = getCursorASTUnit(cursor); CodeCompletionResult Result(namedDecl, CCP_Declaration); CodeCompletionString *String = Result.CreateCodeCompletionString(unit->getASTContext(), unit->getPreprocessor(), unit->getCodeCompletionTUInfo().getAllocator(), unit->getCodeCompletionTUInfo(), true); return String; } } else if (kind == CXCursor_MacroDefinition) { const MacroDefinition *definition = getCursorMacroDefinition(cursor); const IdentifierInfo *MacroInfo = definition->getName(); ASTUnit *unit = getCursorASTUnit(cursor); CodeCompletionResult Result(MacroInfo); CodeCompletionString *String = Result.CreateCodeCompletionString(unit->getASTContext(), unit->getPreprocessor(), unit->getCodeCompletionTUInfo().getAllocator(), unit->getCodeCompletionTUInfo(), false); return String; } return NULL; } } // end: extern C. namespace { struct OverridenCursorsPool { typedef SmallVector CursorVec; std::vector AllCursors; std::vector AvailableCursors; ~OverridenCursorsPool() { for (std::vector::iterator I = AllCursors.begin(), E = AllCursors.end(); I != E; ++I) { delete *I; } } }; } void *cxcursor::createOverridenCXCursorsPool() { return new OverridenCursorsPool(); } void cxcursor::disposeOverridenCXCursorsPool(void *pool) { delete static_cast(pool); } extern "C" { void clang_getOverriddenCursors(CXCursor cursor, CXCursor **overridden, unsigned *num_overridden) { if (overridden) *overridden = 0; if (num_overridden) *num_overridden = 0; CXTranslationUnit TU = cxcursor::getCursorTU(cursor); if (!overridden || !num_overridden || !TU) return; if (!clang_isDeclaration(cursor.kind)) return; OverridenCursorsPool &pool = *static_cast(TU->OverridenCursorsPool); OverridenCursorsPool::CursorVec *Vec = 0; if (!pool.AvailableCursors.empty()) { Vec = pool.AvailableCursors.back(); pool.AvailableCursors.pop_back(); } else { Vec = new OverridenCursorsPool::CursorVec(); pool.AllCursors.push_back(Vec); } // Clear out the vector, but don't free the memory contents. This // reduces malloc() traffic. Vec->clear(); // Use the first entry to contain a back reference to the vector. // This is a complete hack. CXCursor backRefCursor = MakeCXCursorInvalid(CXCursor_InvalidFile, TU); backRefCursor.data[0] = Vec; assert(cxcursor::getCursorTU(backRefCursor) == TU); Vec->push_back(backRefCursor); // Get the overriden cursors. cxcursor::getOverriddenCursors(cursor, *Vec); // Did we get any overriden cursors? If not, return Vec to the pool // of available cursor vectors. if (Vec->size() == 1) { pool.AvailableCursors.push_back(Vec); return; } // Now tell the caller about the overriden cursors. assert(Vec->size() > 1); *overridden = &((*Vec)[1]); *num_overridden = Vec->size() - 1; } void clang_disposeOverriddenCursors(CXCursor *overridden) { if (!overridden) return; // Use pointer arithmetic to get back the first faux entry // which has a back-reference to the TU and the vector. --overridden; OverridenCursorsPool::CursorVec *Vec = static_cast( const_cast(overridden->data[0])); CXTranslationUnit TU = getCursorTU(*overridden); assert(Vec && TU); OverridenCursorsPool &pool = *static_cast(TU->OverridenCursorsPool); pool.AvailableCursors.push_back(Vec); } int clang_Cursor_isDynamicCall(CXCursor C) { const Expr *E = 0; if (clang_isExpression(C.kind)) E = getCursorExpr(C); if (!E) return 0; if (const ObjCMessageExpr *MsgE = dyn_cast(E)) return MsgE->getReceiverKind() == ObjCMessageExpr::Instance; const MemberExpr *ME = 0; if (isa(E)) ME = cast(E); else if (const CallExpr *CE = dyn_cast(E)) ME = dyn_cast_or_null(CE->getCallee()); if (ME) { if (const CXXMethodDecl * MD = dyn_cast_or_null(ME->getMemberDecl())) return MD->isVirtual() && !ME->hasQualifier(); } return 0; } CXType clang_Cursor_getReceiverType(CXCursor C) { CXTranslationUnit TU = cxcursor::getCursorTU(C); const Expr *E = 0; if (clang_isExpression(C.kind)) E = getCursorExpr(C); if (const ObjCMessageExpr *MsgE = dyn_cast_or_null(E)) return cxtype::MakeCXType(MsgE->getReceiverType(), TU); return cxtype::MakeCXType(QualType(), TU); } } // end: extern "C" @