CIndex.cpp revision 8be80e1e6effd5a333bc70e7f030dc9397d0554e
1//===- CIndex.cpp - Clang-C Source Indexing Library -----------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the main API hooks in the Clang-C Source Indexing 11// library. 12// 13//===----------------------------------------------------------------------===// 14 15#include "CIndexer.h" 16#include "CXCursor.h" 17#include "CXTranslationUnit.h" 18#include "CXString.h" 19#include "CXType.h" 20#include "CXSourceLocation.h" 21#include "CIndexDiagnostic.h" 22 23#include "clang/Basic/Version.h" 24 25#include "clang/AST/DeclVisitor.h" 26#include "clang/AST/StmtVisitor.h" 27#include "clang/AST/TypeLocVisitor.h" 28#include "clang/Basic/Diagnostic.h" 29#include "clang/Frontend/ASTUnit.h" 30#include "clang/Frontend/CompilerInstance.h" 31#include "clang/Frontend/FrontendDiagnostic.h" 32#include "clang/Lex/Lexer.h" 33#include "clang/Lex/HeaderSearch.h" 34#include "clang/Lex/PreprocessingRecord.h" 35#include "clang/Lex/Preprocessor.h" 36#include "llvm/ADT/STLExtras.h" 37#include "llvm/ADT/Optional.h" 38#include "llvm/ADT/StringSwitch.h" 39#include "clang/Analysis/Support/SaveAndRestore.h" 40#include "llvm/Support/CrashRecoveryContext.h" 41#include "llvm/Support/PrettyStackTrace.h" 42#include "llvm/Support/MemoryBuffer.h" 43#include "llvm/Support/raw_ostream.h" 44#include "llvm/Support/Timer.h" 45#include "llvm/Support/Mutex.h" 46#include "llvm/Support/Program.h" 47#include "llvm/Support/Signals.h" 48#include "llvm/Support/Threading.h" 49#include "llvm/Support/Compiler.h" 50 51using namespace clang; 52using namespace clang::cxcursor; 53using namespace clang::cxstring; 54 55static CXTranslationUnit MakeCXTranslationUnit(ASTUnit *TU) { 56 if (!TU) 57 return 0; 58 CXTranslationUnit D = new CXTranslationUnitImpl(); 59 D->TUData = TU; 60 D->StringPool = createCXStringPool(); 61 return D; 62} 63 64/// \brief The result of comparing two source ranges. 65enum RangeComparisonResult { 66 /// \brief Either the ranges overlap or one of the ranges is invalid. 67 RangeOverlap, 68 69 /// \brief The first range ends before the second range starts. 70 RangeBefore, 71 72 /// \brief The first range starts after the second range ends. 73 RangeAfter 74}; 75 76/// \brief Compare two source ranges to determine their relative position in 77/// the translation unit. 78static RangeComparisonResult RangeCompare(SourceManager &SM, 79 SourceRange R1, 80 SourceRange R2) { 81 assert(R1.isValid() && "First range is invalid?"); 82 assert(R2.isValid() && "Second range is invalid?"); 83 if (R1.getEnd() != R2.getBegin() && 84 SM.isBeforeInTranslationUnit(R1.getEnd(), R2.getBegin())) 85 return RangeBefore; 86 if (R2.getEnd() != R1.getBegin() && 87 SM.isBeforeInTranslationUnit(R2.getEnd(), R1.getBegin())) 88 return RangeAfter; 89 return RangeOverlap; 90} 91 92/// \brief Determine if a source location falls within, before, or after a 93/// a given source range. 94static RangeComparisonResult LocationCompare(SourceManager &SM, 95 SourceLocation L, SourceRange R) { 96 assert(R.isValid() && "First range is invalid?"); 97 assert(L.isValid() && "Second range is invalid?"); 98 if (L == R.getBegin() || L == R.getEnd()) 99 return RangeOverlap; 100 if (SM.isBeforeInTranslationUnit(L, R.getBegin())) 101 return RangeBefore; 102 if (SM.isBeforeInTranslationUnit(R.getEnd(), L)) 103 return RangeAfter; 104 return RangeOverlap; 105} 106 107/// \brief Translate a Clang source range into a CIndex source range. 108/// 109/// Clang internally represents ranges where the end location points to the 110/// start of the token at the end. However, for external clients it is more 111/// useful to have a CXSourceRange be a proper half-open interval. This routine 112/// does the appropriate translation. 113CXSourceRange cxloc::translateSourceRange(const SourceManager &SM, 114 const LangOptions &LangOpts, 115 const CharSourceRange &R) { 116 // We want the last character in this location, so we will adjust the 117 // location accordingly. 118 SourceLocation EndLoc = R.getEnd(); 119 if (EndLoc.isValid() && EndLoc.isMacroID()) 120 EndLoc = SM.getInstantiationRange(EndLoc).second; 121 if (R.isTokenRange() && !EndLoc.isInvalid() && EndLoc.isFileID()) { 122 unsigned Length = Lexer::MeasureTokenLength(EndLoc, SM, LangOpts); 123 EndLoc = EndLoc.getFileLocWithOffset(Length); 124 } 125 126 CXSourceRange Result = { { (void *)&SM, (void *)&LangOpts }, 127 R.getBegin().getRawEncoding(), 128 EndLoc.getRawEncoding() }; 129 return Result; 130} 131 132//===----------------------------------------------------------------------===// 133// Cursor visitor. 134//===----------------------------------------------------------------------===// 135 136namespace { 137 138class VisitorJob { 139public: 140 enum Kind { DeclVisitKind, StmtVisitKind, MemberExprPartsKind, 141 TypeLocVisitKind, OverloadExprPartsKind, 142 DeclRefExprPartsKind, LabelRefVisitKind, 143 ExplicitTemplateArgsVisitKind, 144 NestedNameSpecifierVisitKind, 145 NestedNameSpecifierLocVisitKind, 146 DeclarationNameInfoVisitKind, 147 MemberRefVisitKind, SizeOfPackExprPartsKind }; 148protected: 149 void *data[3]; 150 CXCursor parent; 151 Kind K; 152 VisitorJob(CXCursor C, Kind k, void *d1, void *d2 = 0, void *d3 = 0) 153 : parent(C), K(k) { 154 data[0] = d1; 155 data[1] = d2; 156 data[2] = d3; 157 } 158public: 159 Kind getKind() const { return K; } 160 const CXCursor &getParent() const { return parent; } 161 static bool classof(VisitorJob *VJ) { return true; } 162}; 163 164typedef llvm::SmallVector<VisitorJob, 10> VisitorWorkList; 165 166// Cursor visitor. 167class CursorVisitor : public DeclVisitor<CursorVisitor, bool>, 168 public TypeLocVisitor<CursorVisitor, bool> 169{ 170 /// \brief The translation unit we are traversing. 171 CXTranslationUnit TU; 172 ASTUnit *AU; 173 174 /// \brief The parent cursor whose children we are traversing. 175 CXCursor Parent; 176 177 /// \brief The declaration that serves at the parent of any statement or 178 /// expression nodes. 179 Decl *StmtParent; 180 181 /// \brief The visitor function. 182 CXCursorVisitor Visitor; 183 184 /// \brief The opaque client data, to be passed along to the visitor. 185 CXClientData ClientData; 186 187 // MaxPCHLevel - the maximum PCH level of declarations that we will pass on 188 // to the visitor. Declarations with a PCH level greater than this value will 189 // be suppressed. 190 unsigned MaxPCHLevel; 191 192 /// \brief Whether we should visit the preprocessing record entries last, 193 /// after visiting other declarations. 194 bool VisitPreprocessorLast; 195 196 /// \brief When valid, a source range to which the cursor should restrict 197 /// its search. 198 SourceRange RegionOfInterest; 199 200 // FIXME: Eventually remove. This part of a hack to support proper 201 // iteration over all Decls contained lexically within an ObjC container. 202 DeclContext::decl_iterator *DI_current; 203 DeclContext::decl_iterator DE_current; 204 205 // Cache of pre-allocated worklists for data-recursion walk of Stmts. 206 llvm::SmallVector<VisitorWorkList*, 5> WorkListFreeList; 207 llvm::SmallVector<VisitorWorkList*, 5> WorkListCache; 208 209 using DeclVisitor<CursorVisitor, bool>::Visit; 210 using TypeLocVisitor<CursorVisitor, bool>::Visit; 211 212 /// \brief Determine whether this particular source range comes before, comes 213 /// after, or overlaps the region of interest. 214 /// 215 /// \param R a half-open source range retrieved from the abstract syntax tree. 216 RangeComparisonResult CompareRegionOfInterest(SourceRange R); 217 218 class SetParentRAII { 219 CXCursor &Parent; 220 Decl *&StmtParent; 221 CXCursor OldParent; 222 223 public: 224 SetParentRAII(CXCursor &Parent, Decl *&StmtParent, CXCursor NewParent) 225 : Parent(Parent), StmtParent(StmtParent), OldParent(Parent) 226 { 227 Parent = NewParent; 228 if (clang_isDeclaration(Parent.kind)) 229 StmtParent = getCursorDecl(Parent); 230 } 231 232 ~SetParentRAII() { 233 Parent = OldParent; 234 if (clang_isDeclaration(Parent.kind)) 235 StmtParent = getCursorDecl(Parent); 236 } 237 }; 238 239public: 240 CursorVisitor(CXTranslationUnit TU, CXCursorVisitor Visitor, 241 CXClientData ClientData, 242 unsigned MaxPCHLevel, 243 bool VisitPreprocessorLast, 244 SourceRange RegionOfInterest = SourceRange()) 245 : TU(TU), AU(static_cast<ASTUnit*>(TU->TUData)), 246 Visitor(Visitor), ClientData(ClientData), 247 MaxPCHLevel(MaxPCHLevel), VisitPreprocessorLast(VisitPreprocessorLast), 248 RegionOfInterest(RegionOfInterest), DI_current(0) 249 { 250 Parent.kind = CXCursor_NoDeclFound; 251 Parent.data[0] = 0; 252 Parent.data[1] = 0; 253 Parent.data[2] = 0; 254 StmtParent = 0; 255 } 256 257 ~CursorVisitor() { 258 // Free the pre-allocated worklists for data-recursion. 259 for (llvm::SmallVectorImpl<VisitorWorkList*>::iterator 260 I = WorkListCache.begin(), E = WorkListCache.end(); I != E; ++I) { 261 delete *I; 262 } 263 } 264 265 ASTUnit *getASTUnit() const { return static_cast<ASTUnit*>(TU->TUData); } 266 CXTranslationUnit getTU() const { return TU; } 267 268 bool Visit(CXCursor Cursor, bool CheckedRegionOfInterest = false); 269 270 std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator> 271 getPreprocessedEntities(); 272 273 bool VisitChildren(CXCursor Parent); 274 275 // Declaration visitors 276 bool VisitTypeAliasDecl(TypeAliasDecl *D); 277 bool VisitAttributes(Decl *D); 278 bool VisitBlockDecl(BlockDecl *B); 279 bool VisitCXXRecordDecl(CXXRecordDecl *D); 280 llvm::Optional<bool> shouldVisitCursor(CXCursor C); 281 bool VisitDeclContext(DeclContext *DC); 282 bool VisitTranslationUnitDecl(TranslationUnitDecl *D); 283 bool VisitTypedefDecl(TypedefDecl *D); 284 bool VisitTagDecl(TagDecl *D); 285 bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D); 286 bool VisitClassTemplatePartialSpecializationDecl( 287 ClassTemplatePartialSpecializationDecl *D); 288 bool VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); 289 bool VisitEnumConstantDecl(EnumConstantDecl *D); 290 bool VisitDeclaratorDecl(DeclaratorDecl *DD); 291 bool VisitFunctionDecl(FunctionDecl *ND); 292 bool VisitFieldDecl(FieldDecl *D); 293 bool VisitVarDecl(VarDecl *); 294 bool VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); 295 bool VisitFunctionTemplateDecl(FunctionTemplateDecl *D); 296 bool VisitClassTemplateDecl(ClassTemplateDecl *D); 297 bool VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); 298 bool VisitObjCMethodDecl(ObjCMethodDecl *ND); 299 bool VisitObjCContainerDecl(ObjCContainerDecl *D); 300 bool VisitObjCCategoryDecl(ObjCCategoryDecl *ND); 301 bool VisitObjCProtocolDecl(ObjCProtocolDecl *PID); 302 bool VisitObjCPropertyDecl(ObjCPropertyDecl *PD); 303 bool VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); 304 bool VisitObjCImplDecl(ObjCImplDecl *D); 305 bool VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D); 306 bool VisitObjCImplementationDecl(ObjCImplementationDecl *D); 307 // FIXME: ObjCCompatibleAliasDecl requires aliased-class locations. 308 bool VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D); 309 bool VisitObjCClassDecl(ObjCClassDecl *D); 310 bool VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PD); 311 bool VisitLinkageSpecDecl(LinkageSpecDecl *D); 312 bool VisitNamespaceDecl(NamespaceDecl *D); 313 bool VisitNamespaceAliasDecl(NamespaceAliasDecl *D); 314 bool VisitUsingDirectiveDecl(UsingDirectiveDecl *D); 315 bool VisitUsingDecl(UsingDecl *D); 316 bool VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); 317 bool VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); 318 319 // Name visitor 320 bool VisitDeclarationNameInfo(DeclarationNameInfo Name); 321 bool VisitNestedNameSpecifier(NestedNameSpecifier *NNS, SourceRange Range); 322 bool VisitNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS); 323 324 // Template visitors 325 bool VisitTemplateParameters(const TemplateParameterList *Params); 326 bool VisitTemplateName(TemplateName Name, SourceLocation Loc); 327 bool VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL); 328 329 // Type visitors 330 bool VisitQualifiedTypeLoc(QualifiedTypeLoc TL); 331 bool VisitBuiltinTypeLoc(BuiltinTypeLoc TL); 332 bool VisitTypedefTypeLoc(TypedefTypeLoc TL); 333 bool VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL); 334 bool VisitTagTypeLoc(TagTypeLoc TL); 335 bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL); 336 bool VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL); 337 bool VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL); 338 bool VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL); 339 bool VisitParenTypeLoc(ParenTypeLoc TL); 340 bool VisitPointerTypeLoc(PointerTypeLoc TL); 341 bool VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL); 342 bool VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL); 343 bool VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL); 344 bool VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL); 345 bool VisitFunctionTypeLoc(FunctionTypeLoc TL, bool SkipResultType = false); 346 bool VisitArrayTypeLoc(ArrayTypeLoc TL); 347 bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL); 348 // FIXME: Implement visitors here when the unimplemented TypeLocs get 349 // implemented 350 bool VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL); 351 bool VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL); 352 bool VisitTypeOfTypeLoc(TypeOfTypeLoc TL); 353 bool VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL); 354 bool VisitDependentNameTypeLoc(DependentNameTypeLoc TL); 355 bool VisitDependentTemplateSpecializationTypeLoc( 356 DependentTemplateSpecializationTypeLoc TL); 357 bool VisitElaboratedTypeLoc(ElaboratedTypeLoc TL); 358 359 // Data-recursive visitor functions. 360 bool IsInRegionOfInterest(CXCursor C); 361 bool RunVisitorWorkList(VisitorWorkList &WL); 362 void EnqueueWorkList(VisitorWorkList &WL, Stmt *S); 363 LLVM_ATTRIBUTE_NOINLINE bool Visit(Stmt *S); 364}; 365 366} // end anonymous namespace 367 368static SourceRange getRawCursorExtent(CXCursor C); 369static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr); 370 371 372RangeComparisonResult CursorVisitor::CompareRegionOfInterest(SourceRange R) { 373 return RangeCompare(AU->getSourceManager(), R, RegionOfInterest); 374} 375 376/// \brief Visit the given cursor and, if requested by the visitor, 377/// its children. 378/// 379/// \param Cursor the cursor to visit. 380/// 381/// \param CheckRegionOfInterest if true, then the caller already checked that 382/// this cursor is within the region of interest. 383/// 384/// \returns true if the visitation should be aborted, false if it 385/// should continue. 386bool CursorVisitor::Visit(CXCursor Cursor, bool CheckedRegionOfInterest) { 387 if (clang_isInvalid(Cursor.kind)) 388 return false; 389 390 if (clang_isDeclaration(Cursor.kind)) { 391 Decl *D = getCursorDecl(Cursor); 392 assert(D && "Invalid declaration cursor"); 393 if (D->getPCHLevel() > MaxPCHLevel) 394 return false; 395 396 if (D->isImplicit()) 397 return false; 398 } 399 400 // If we have a range of interest, and this cursor doesn't intersect with it, 401 // we're done. 402 if (RegionOfInterest.isValid() && !CheckedRegionOfInterest) { 403 SourceRange Range = getRawCursorExtent(Cursor); 404 if (Range.isInvalid() || CompareRegionOfInterest(Range)) 405 return false; 406 } 407 408 switch (Visitor(Cursor, Parent, ClientData)) { 409 case CXChildVisit_Break: 410 return true; 411 412 case CXChildVisit_Continue: 413 return false; 414 415 case CXChildVisit_Recurse: 416 return VisitChildren(Cursor); 417 } 418 419 return false; 420} 421 422std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator> 423CursorVisitor::getPreprocessedEntities() { 424 PreprocessingRecord &PPRec 425 = *AU->getPreprocessor().getPreprocessingRecord(); 426 427 bool OnlyLocalDecls 428 = !AU->isMainFileAST() && AU->getOnlyLocalDecls(); 429 430 if (OnlyLocalDecls && RegionOfInterest.isValid()) { 431 // If we would only look at local declarations but we have a region of 432 // interest, check whether that region of interest is in the main file. 433 // If not, we should traverse all declarations. 434 // FIXME: My kingdom for a proper binary search approach to finding 435 // cursors! 436 std::pair<FileID, unsigned> Location 437 = AU->getSourceManager().getDecomposedInstantiationLoc( 438 RegionOfInterest.getBegin()); 439 if (Location.first != AU->getSourceManager().getMainFileID()) 440 OnlyLocalDecls = false; 441 } 442 443 PreprocessingRecord::iterator StartEntity, EndEntity; 444 if (OnlyLocalDecls) { 445 StartEntity = AU->pp_entity_begin(); 446 EndEntity = AU->pp_entity_end(); 447 } else { 448 StartEntity = PPRec.begin(); 449 EndEntity = PPRec.end(); 450 } 451 452 // There is no region of interest; we have to walk everything. 453 if (RegionOfInterest.isInvalid()) 454 return std::make_pair(StartEntity, EndEntity); 455 456 // Find the file in which the region of interest lands. 457 SourceManager &SM = AU->getSourceManager(); 458 std::pair<FileID, unsigned> Begin 459 = SM.getDecomposedInstantiationLoc(RegionOfInterest.getBegin()); 460 std::pair<FileID, unsigned> End 461 = SM.getDecomposedInstantiationLoc(RegionOfInterest.getEnd()); 462 463 // The region of interest spans files; we have to walk everything. 464 if (Begin.first != End.first) 465 return std::make_pair(StartEntity, EndEntity); 466 467 ASTUnit::PreprocessedEntitiesByFileMap &ByFileMap 468 = AU->getPreprocessedEntitiesByFile(); 469 if (ByFileMap.empty()) { 470 // Build the mapping from files to sets of preprocessed entities. 471 for (PreprocessingRecord::iterator E = StartEntity; E != EndEntity; ++E) { 472 std::pair<FileID, unsigned> P 473 = SM.getDecomposedInstantiationLoc((*E)->getSourceRange().getBegin()); 474 475 ByFileMap[P.first].push_back(*E); 476 } 477 } 478 479 return std::make_pair(ByFileMap[Begin.first].begin(), 480 ByFileMap[Begin.first].end()); 481} 482 483/// \brief Visit the children of the given cursor. 484/// 485/// \returns true if the visitation should be aborted, false if it 486/// should continue. 487bool CursorVisitor::VisitChildren(CXCursor Cursor) { 488 if (clang_isReference(Cursor.kind) && 489 Cursor.kind != CXCursor_CXXBaseSpecifier) { 490 // By definition, references have no children. 491 return false; 492 } 493 494 // Set the Parent field to Cursor, then back to its old value once we're 495 // done. 496 SetParentRAII SetParent(Parent, StmtParent, Cursor); 497 498 if (clang_isDeclaration(Cursor.kind)) { 499 Decl *D = getCursorDecl(Cursor); 500 if (!D) 501 return false; 502 503 return VisitAttributes(D) || Visit(D); 504 } 505 506 if (clang_isStatement(Cursor.kind)) { 507 if (Stmt *S = getCursorStmt(Cursor)) 508 return Visit(S); 509 510 return false; 511 } 512 513 if (clang_isExpression(Cursor.kind)) { 514 if (Expr *E = getCursorExpr(Cursor)) 515 return Visit(E); 516 517 return false; 518 } 519 520 if (clang_isTranslationUnit(Cursor.kind)) { 521 CXTranslationUnit tu = getCursorTU(Cursor); 522 ASTUnit *CXXUnit = static_cast<ASTUnit*>(tu->TUData); 523 524 int VisitOrder[2] = { VisitPreprocessorLast, !VisitPreprocessorLast }; 525 for (unsigned I = 0; I != 2; ++I) { 526 if (VisitOrder[I]) { 527 if (!CXXUnit->isMainFileAST() && CXXUnit->getOnlyLocalDecls() && 528 RegionOfInterest.isInvalid()) { 529 for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(), 530 TLEnd = CXXUnit->top_level_end(); 531 TL != TLEnd; ++TL) { 532 if (Visit(MakeCXCursor(*TL, tu), true)) 533 return true; 534 } 535 } else if (VisitDeclContext( 536 CXXUnit->getASTContext().getTranslationUnitDecl())) 537 return true; 538 continue; 539 } 540 541 // Walk the preprocessing record. 542 if (CXXUnit->getPreprocessor().getPreprocessingRecord()) { 543 // FIXME: Once we have the ability to deserialize a preprocessing record, 544 // do so. 545 PreprocessingRecord::iterator E, EEnd; 546 for (llvm::tie(E, EEnd) = getPreprocessedEntities(); E != EEnd; ++E) { 547 if (MacroInstantiation *MI = dyn_cast<MacroInstantiation>(*E)) { 548 if (Visit(MakeMacroInstantiationCursor(MI, tu))) 549 return true; 550 551 continue; 552 } 553 554 if (MacroDefinition *MD = dyn_cast<MacroDefinition>(*E)) { 555 if (Visit(MakeMacroDefinitionCursor(MD, tu))) 556 return true; 557 558 continue; 559 } 560 561 if (InclusionDirective *ID = dyn_cast<InclusionDirective>(*E)) { 562 if (Visit(MakeInclusionDirectiveCursor(ID, tu))) 563 return true; 564 565 continue; 566 } 567 } 568 } 569 } 570 571 return false; 572 } 573 574 if (Cursor.kind == CXCursor_CXXBaseSpecifier) { 575 if (CXXBaseSpecifier *Base = getCursorCXXBaseSpecifier(Cursor)) { 576 if (TypeSourceInfo *BaseTSInfo = Base->getTypeSourceInfo()) { 577 return Visit(BaseTSInfo->getTypeLoc()); 578 } 579 } 580 } 581 582 // Nothing to visit at the moment. 583 return false; 584} 585 586bool CursorVisitor::VisitBlockDecl(BlockDecl *B) { 587 if (TypeSourceInfo *TSInfo = B->getSignatureAsWritten()) 588 if (Visit(TSInfo->getTypeLoc())) 589 return true; 590 591 if (Stmt *Body = B->getBody()) 592 return Visit(MakeCXCursor(Body, StmtParent, TU)); 593 594 return false; 595} 596 597llvm::Optional<bool> CursorVisitor::shouldVisitCursor(CXCursor Cursor) { 598 if (RegionOfInterest.isValid()) { 599 SourceRange Range = getFullCursorExtent(Cursor, AU->getSourceManager()); 600 if (Range.isInvalid()) 601 return llvm::Optional<bool>(); 602 603 switch (CompareRegionOfInterest(Range)) { 604 case RangeBefore: 605 // This declaration comes before the region of interest; skip it. 606 return llvm::Optional<bool>(); 607 608 case RangeAfter: 609 // This declaration comes after the region of interest; we're done. 610 return false; 611 612 case RangeOverlap: 613 // This declaration overlaps the region of interest; visit it. 614 break; 615 } 616 } 617 return true; 618} 619 620bool CursorVisitor::VisitDeclContext(DeclContext *DC) { 621 DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end(); 622 623 // FIXME: Eventually remove. This part of a hack to support proper 624 // iteration over all Decls contained lexically within an ObjC container. 625 SaveAndRestore<DeclContext::decl_iterator*> DI_saved(DI_current, &I); 626 SaveAndRestore<DeclContext::decl_iterator> DE_saved(DE_current, E); 627 628 for ( ; I != E; ++I) { 629 Decl *D = *I; 630 if (D->getLexicalDeclContext() != DC) 631 continue; 632 CXCursor Cursor = MakeCXCursor(D, TU); 633 const llvm::Optional<bool> &V = shouldVisitCursor(Cursor); 634 if (!V.hasValue()) 635 continue; 636 if (!V.getValue()) 637 return false; 638 if (Visit(Cursor, true)) 639 return true; 640 } 641 return false; 642} 643 644bool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 645 llvm_unreachable("Translation units are visited directly by Visit()"); 646 return false; 647} 648 649bool CursorVisitor::VisitTypeAliasDecl(TypeAliasDecl *D) { 650 if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo()) 651 return Visit(TSInfo->getTypeLoc()); 652 653 return false; 654} 655 656bool CursorVisitor::VisitTypedefDecl(TypedefDecl *D) { 657 if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo()) 658 return Visit(TSInfo->getTypeLoc()); 659 660 return false; 661} 662 663bool CursorVisitor::VisitTagDecl(TagDecl *D) { 664 return VisitDeclContext(D); 665} 666 667bool CursorVisitor::VisitClassTemplateSpecializationDecl( 668 ClassTemplateSpecializationDecl *D) { 669 bool ShouldVisitBody = false; 670 switch (D->getSpecializationKind()) { 671 case TSK_Undeclared: 672 case TSK_ImplicitInstantiation: 673 // Nothing to visit 674 return false; 675 676 case TSK_ExplicitInstantiationDeclaration: 677 case TSK_ExplicitInstantiationDefinition: 678 break; 679 680 case TSK_ExplicitSpecialization: 681 ShouldVisitBody = true; 682 break; 683 } 684 685 // Visit the template arguments used in the specialization. 686 if (TypeSourceInfo *SpecType = D->getTypeAsWritten()) { 687 TypeLoc TL = SpecType->getTypeLoc(); 688 if (TemplateSpecializationTypeLoc *TSTLoc 689 = dyn_cast<TemplateSpecializationTypeLoc>(&TL)) { 690 for (unsigned I = 0, N = TSTLoc->getNumArgs(); I != N; ++I) 691 if (VisitTemplateArgumentLoc(TSTLoc->getArgLoc(I))) 692 return true; 693 } 694 } 695 696 if (ShouldVisitBody && VisitCXXRecordDecl(D)) 697 return true; 698 699 return false; 700} 701 702bool CursorVisitor::VisitClassTemplatePartialSpecializationDecl( 703 ClassTemplatePartialSpecializationDecl *D) { 704 // FIXME: Visit the "outer" template parameter lists on the TagDecl 705 // before visiting these template parameters. 706 if (VisitTemplateParameters(D->getTemplateParameters())) 707 return true; 708 709 // Visit the partial specialization arguments. 710 const TemplateArgumentLoc *TemplateArgs = D->getTemplateArgsAsWritten(); 711 for (unsigned I = 0, N = D->getNumTemplateArgsAsWritten(); I != N; ++I) 712 if (VisitTemplateArgumentLoc(TemplateArgs[I])) 713 return true; 714 715 return VisitCXXRecordDecl(D); 716} 717 718bool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 719 // Visit the default argument. 720 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) 721 if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo()) 722 if (Visit(DefArg->getTypeLoc())) 723 return true; 724 725 return false; 726} 727 728bool CursorVisitor::VisitEnumConstantDecl(EnumConstantDecl *D) { 729 if (Expr *Init = D->getInitExpr()) 730 return Visit(MakeCXCursor(Init, StmtParent, TU)); 731 return false; 732} 733 734bool CursorVisitor::VisitDeclaratorDecl(DeclaratorDecl *DD) { 735 if (TypeSourceInfo *TSInfo = DD->getTypeSourceInfo()) 736 if (Visit(TSInfo->getTypeLoc())) 737 return true; 738 739 // Visit the nested-name-specifier, if present. 740 if (NestedNameSpecifierLoc QualifierLoc = DD->getQualifierLoc()) 741 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 742 return true; 743 744 return false; 745} 746 747/// \brief Compare two base or member initializers based on their source order. 748static int CompareCXXCtorInitializers(const void* Xp, const void *Yp) { 749 CXXCtorInitializer const * const *X 750 = static_cast<CXXCtorInitializer const * const *>(Xp); 751 CXXCtorInitializer const * const *Y 752 = static_cast<CXXCtorInitializer const * const *>(Yp); 753 754 if ((*X)->getSourceOrder() < (*Y)->getSourceOrder()) 755 return -1; 756 else if ((*X)->getSourceOrder() > (*Y)->getSourceOrder()) 757 return 1; 758 else 759 return 0; 760} 761 762bool CursorVisitor::VisitFunctionDecl(FunctionDecl *ND) { 763 if (TypeSourceInfo *TSInfo = ND->getTypeSourceInfo()) { 764 // Visit the function declaration's syntactic components in the order 765 // written. This requires a bit of work. 766 TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens(); 767 FunctionTypeLoc *FTL = dyn_cast<FunctionTypeLoc>(&TL); 768 769 // If we have a function declared directly (without the use of a typedef), 770 // visit just the return type. Otherwise, just visit the function's type 771 // now. 772 if ((FTL && !isa<CXXConversionDecl>(ND) && Visit(FTL->getResultLoc())) || 773 (!FTL && Visit(TL))) 774 return true; 775 776 // Visit the nested-name-specifier, if present. 777 if (NestedNameSpecifierLoc QualifierLoc = ND->getQualifierLoc()) 778 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 779 return true; 780 781 // Visit the declaration name. 782 if (VisitDeclarationNameInfo(ND->getNameInfo())) 783 return true; 784 785 // FIXME: Visit explicitly-specified template arguments! 786 787 // Visit the function parameters, if we have a function type. 788 if (FTL && VisitFunctionTypeLoc(*FTL, true)) 789 return true; 790 791 // FIXME: Attributes? 792 } 793 794 if (ND->doesThisDeclarationHaveABody() && !ND->isLateTemplateParsed()) { 795 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ND)) { 796 // Find the initializers that were written in the source. 797 llvm::SmallVector<CXXCtorInitializer *, 4> WrittenInits; 798 for (CXXConstructorDecl::init_iterator I = Constructor->init_begin(), 799 IEnd = Constructor->init_end(); 800 I != IEnd; ++I) { 801 if (!(*I)->isWritten()) 802 continue; 803 804 WrittenInits.push_back(*I); 805 } 806 807 // Sort the initializers in source order 808 llvm::array_pod_sort(WrittenInits.begin(), WrittenInits.end(), 809 &CompareCXXCtorInitializers); 810 811 // Visit the initializers in source order 812 for (unsigned I = 0, N = WrittenInits.size(); I != N; ++I) { 813 CXXCtorInitializer *Init = WrittenInits[I]; 814 if (Init->isAnyMemberInitializer()) { 815 if (Visit(MakeCursorMemberRef(Init->getAnyMember(), 816 Init->getMemberLocation(), TU))) 817 return true; 818 } else if (TypeSourceInfo *BaseInfo = Init->getBaseClassInfo()) { 819 if (Visit(BaseInfo->getTypeLoc())) 820 return true; 821 } 822 823 // Visit the initializer value. 824 if (Expr *Initializer = Init->getInit()) 825 if (Visit(MakeCXCursor(Initializer, ND, TU))) 826 return true; 827 } 828 } 829 830 if (Visit(MakeCXCursor(ND->getBody(), StmtParent, TU))) 831 return true; 832 } 833 834 return false; 835} 836 837bool CursorVisitor::VisitFieldDecl(FieldDecl *D) { 838 if (VisitDeclaratorDecl(D)) 839 return true; 840 841 if (Expr *BitWidth = D->getBitWidth()) 842 return Visit(MakeCXCursor(BitWidth, StmtParent, TU)); 843 844 return false; 845} 846 847bool CursorVisitor::VisitVarDecl(VarDecl *D) { 848 if (VisitDeclaratorDecl(D)) 849 return true; 850 851 if (Expr *Init = D->getInit()) 852 return Visit(MakeCXCursor(Init, StmtParent, TU)); 853 854 return false; 855} 856 857bool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 858 if (VisitDeclaratorDecl(D)) 859 return true; 860 861 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) 862 if (Expr *DefArg = D->getDefaultArgument()) 863 return Visit(MakeCXCursor(DefArg, StmtParent, TU)); 864 865 return false; 866} 867 868bool CursorVisitor::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 869 // FIXME: Visit the "outer" template parameter lists on the FunctionDecl 870 // before visiting these template parameters. 871 if (VisitTemplateParameters(D->getTemplateParameters())) 872 return true; 873 874 return VisitFunctionDecl(D->getTemplatedDecl()); 875} 876 877bool CursorVisitor::VisitClassTemplateDecl(ClassTemplateDecl *D) { 878 // FIXME: Visit the "outer" template parameter lists on the TagDecl 879 // before visiting these template parameters. 880 if (VisitTemplateParameters(D->getTemplateParameters())) 881 return true; 882 883 return VisitCXXRecordDecl(D->getTemplatedDecl()); 884} 885 886bool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 887 if (VisitTemplateParameters(D->getTemplateParameters())) 888 return true; 889 890 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited() && 891 VisitTemplateArgumentLoc(D->getDefaultArgument())) 892 return true; 893 894 return false; 895} 896 897bool CursorVisitor::VisitObjCMethodDecl(ObjCMethodDecl *ND) { 898 if (TypeSourceInfo *TSInfo = ND->getResultTypeSourceInfo()) 899 if (Visit(TSInfo->getTypeLoc())) 900 return true; 901 902 for (ObjCMethodDecl::param_iterator P = ND->param_begin(), 903 PEnd = ND->param_end(); 904 P != PEnd; ++P) { 905 if (Visit(MakeCXCursor(*P, TU))) 906 return true; 907 } 908 909 if (ND->isThisDeclarationADefinition() && 910 Visit(MakeCXCursor(ND->getBody(), StmtParent, TU))) 911 return true; 912 913 return false; 914} 915 916namespace { 917 struct ContainerDeclsSort { 918 SourceManager &SM; 919 ContainerDeclsSort(SourceManager &sm) : SM(sm) {} 920 bool operator()(Decl *A, Decl *B) { 921 SourceLocation L_A = A->getLocStart(); 922 SourceLocation L_B = B->getLocStart(); 923 assert(L_A.isValid() && L_B.isValid()); 924 return SM.isBeforeInTranslationUnit(L_A, L_B); 925 } 926 }; 927} 928 929bool CursorVisitor::VisitObjCContainerDecl(ObjCContainerDecl *D) { 930 // FIXME: Eventually convert back to just 'VisitDeclContext()'. Essentially 931 // an @implementation can lexically contain Decls that are not properly 932 // nested in the AST. When we identify such cases, we need to retrofit 933 // this nesting here. 934 if (!DI_current) 935 return VisitDeclContext(D); 936 937 // Scan the Decls that immediately come after the container 938 // in the current DeclContext. If any fall within the 939 // container's lexical region, stash them into a vector 940 // for later processing. 941 llvm::SmallVector<Decl *, 24> DeclsInContainer; 942 SourceLocation EndLoc = D->getSourceRange().getEnd(); 943 SourceManager &SM = AU->getSourceManager(); 944 if (EndLoc.isValid()) { 945 DeclContext::decl_iterator next = *DI_current; 946 while (++next != DE_current) { 947 Decl *D_next = *next; 948 if (!D_next) 949 break; 950 SourceLocation L = D_next->getLocStart(); 951 if (!L.isValid()) 952 break; 953 if (SM.isBeforeInTranslationUnit(L, EndLoc)) { 954 *DI_current = next; 955 DeclsInContainer.push_back(D_next); 956 continue; 957 } 958 break; 959 } 960 } 961 962 // The common case. 963 if (DeclsInContainer.empty()) 964 return VisitDeclContext(D); 965 966 // Get all the Decls in the DeclContext, and sort them with the 967 // additional ones we've collected. Then visit them. 968 for (DeclContext::decl_iterator I = D->decls_begin(), E = D->decls_end(); 969 I!=E; ++I) { 970 Decl *subDecl = *I; 971 if (!subDecl || subDecl->getLexicalDeclContext() != D || 972 subDecl->getLocStart().isInvalid()) 973 continue; 974 DeclsInContainer.push_back(subDecl); 975 } 976 977 // Now sort the Decls so that they appear in lexical order. 978 std::sort(DeclsInContainer.begin(), DeclsInContainer.end(), 979 ContainerDeclsSort(SM)); 980 981 // Now visit the decls. 982 for (llvm::SmallVectorImpl<Decl*>::iterator I = DeclsInContainer.begin(), 983 E = DeclsInContainer.end(); I != E; ++I) { 984 CXCursor Cursor = MakeCXCursor(*I, TU); 985 const llvm::Optional<bool> &V = shouldVisitCursor(Cursor); 986 if (!V.hasValue()) 987 continue; 988 if (!V.getValue()) 989 return false; 990 if (Visit(Cursor, true)) 991 return true; 992 } 993 return false; 994} 995 996bool CursorVisitor::VisitObjCCategoryDecl(ObjCCategoryDecl *ND) { 997 if (Visit(MakeCursorObjCClassRef(ND->getClassInterface(), ND->getLocation(), 998 TU))) 999 return true; 1000 1001 ObjCCategoryDecl::protocol_loc_iterator PL = ND->protocol_loc_begin(); 1002 for (ObjCCategoryDecl::protocol_iterator I = ND->protocol_begin(), 1003 E = ND->protocol_end(); I != E; ++I, ++PL) 1004 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 1005 return true; 1006 1007 return VisitObjCContainerDecl(ND); 1008} 1009 1010bool CursorVisitor::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) { 1011 ObjCProtocolDecl::protocol_loc_iterator PL = PID->protocol_loc_begin(); 1012 for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(), 1013 E = PID->protocol_end(); I != E; ++I, ++PL) 1014 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 1015 return true; 1016 1017 return VisitObjCContainerDecl(PID); 1018} 1019 1020bool CursorVisitor::VisitObjCPropertyDecl(ObjCPropertyDecl *PD) { 1021 if (PD->getTypeSourceInfo() && Visit(PD->getTypeSourceInfo()->getTypeLoc())) 1022 return true; 1023 1024 // FIXME: This implements a workaround with @property declarations also being 1025 // installed in the DeclContext for the @interface. Eventually this code 1026 // should be removed. 1027 ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(PD->getDeclContext()); 1028 if (!CDecl || !CDecl->IsClassExtension()) 1029 return false; 1030 1031 ObjCInterfaceDecl *ID = CDecl->getClassInterface(); 1032 if (!ID) 1033 return false; 1034 1035 IdentifierInfo *PropertyId = PD->getIdentifier(); 1036 ObjCPropertyDecl *prevDecl = 1037 ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(ID), PropertyId); 1038 1039 if (!prevDecl) 1040 return false; 1041 1042 // Visit synthesized methods since they will be skipped when visiting 1043 // the @interface. 1044 if (ObjCMethodDecl *MD = prevDecl->getGetterMethodDecl()) 1045 if (MD->isSynthesized() && MD->getLexicalDeclContext() == CDecl) 1046 if (Visit(MakeCXCursor(MD, TU))) 1047 return true; 1048 1049 if (ObjCMethodDecl *MD = prevDecl->getSetterMethodDecl()) 1050 if (MD->isSynthesized() && MD->getLexicalDeclContext() == CDecl) 1051 if (Visit(MakeCXCursor(MD, TU))) 1052 return true; 1053 1054 return false; 1055} 1056 1057bool CursorVisitor::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 1058 // Issue callbacks for super class. 1059 if (D->getSuperClass() && 1060 Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(), 1061 D->getSuperClassLoc(), 1062 TU))) 1063 return true; 1064 1065 ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(); 1066 for (ObjCInterfaceDecl::protocol_iterator I = D->protocol_begin(), 1067 E = D->protocol_end(); I != E; ++I, ++PL) 1068 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 1069 return true; 1070 1071 return VisitObjCContainerDecl(D); 1072} 1073 1074bool CursorVisitor::VisitObjCImplDecl(ObjCImplDecl *D) { 1075 return VisitObjCContainerDecl(D); 1076} 1077 1078bool CursorVisitor::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 1079 // 'ID' could be null when dealing with invalid code. 1080 if (ObjCInterfaceDecl *ID = D->getClassInterface()) 1081 if (Visit(MakeCursorObjCClassRef(ID, D->getLocation(), TU))) 1082 return true; 1083 1084 return VisitObjCImplDecl(D); 1085} 1086 1087bool CursorVisitor::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 1088#if 0 1089 // Issue callbacks for super class. 1090 // FIXME: No source location information! 1091 if (D->getSuperClass() && 1092 Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(), 1093 D->getSuperClassLoc(), 1094 TU))) 1095 return true; 1096#endif 1097 1098 return VisitObjCImplDecl(D); 1099} 1100 1101bool CursorVisitor::VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D) { 1102 ObjCForwardProtocolDecl::protocol_loc_iterator PL = D->protocol_loc_begin(); 1103 for (ObjCForwardProtocolDecl::protocol_iterator I = D->protocol_begin(), 1104 E = D->protocol_end(); 1105 I != E; ++I, ++PL) 1106 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 1107 return true; 1108 1109 return false; 1110} 1111 1112bool CursorVisitor::VisitObjCClassDecl(ObjCClassDecl *D) { 1113 for (ObjCClassDecl::iterator C = D->begin(), CEnd = D->end(); C != CEnd; ++C) 1114 if (Visit(MakeCursorObjCClassRef(C->getInterface(), C->getLocation(), TU))) 1115 return true; 1116 1117 return false; 1118} 1119 1120bool CursorVisitor::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PD) { 1121 if (ObjCIvarDecl *Ivar = PD->getPropertyIvarDecl()) 1122 return Visit(MakeCursorMemberRef(Ivar, PD->getPropertyIvarDeclLoc(), TU)); 1123 1124 return false; 1125} 1126 1127bool CursorVisitor::VisitNamespaceDecl(NamespaceDecl *D) { 1128 return VisitDeclContext(D); 1129} 1130 1131bool CursorVisitor::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 1132 // Visit nested-name-specifier. 1133 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1134 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1135 return true; 1136 1137 return Visit(MakeCursorNamespaceRef(D->getAliasedNamespace(), 1138 D->getTargetNameLoc(), TU)); 1139} 1140 1141bool CursorVisitor::VisitUsingDecl(UsingDecl *D) { 1142 // Visit nested-name-specifier. 1143 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) { 1144 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1145 return true; 1146 } 1147 1148 if (Visit(MakeCursorOverloadedDeclRef(D, D->getLocation(), TU))) 1149 return true; 1150 1151 return VisitDeclarationNameInfo(D->getNameInfo()); 1152} 1153 1154bool CursorVisitor::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 1155 // Visit nested-name-specifier. 1156 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1157 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1158 return true; 1159 1160 return Visit(MakeCursorNamespaceRef(D->getNominatedNamespaceAsWritten(), 1161 D->getIdentLocation(), TU)); 1162} 1163 1164bool CursorVisitor::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { 1165 // Visit nested-name-specifier. 1166 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) { 1167 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1168 return true; 1169 } 1170 1171 return VisitDeclarationNameInfo(D->getNameInfo()); 1172} 1173 1174bool CursorVisitor::VisitUnresolvedUsingTypenameDecl( 1175 UnresolvedUsingTypenameDecl *D) { 1176 // Visit nested-name-specifier. 1177 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1178 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1179 return true; 1180 1181 return false; 1182} 1183 1184bool CursorVisitor::VisitDeclarationNameInfo(DeclarationNameInfo Name) { 1185 switch (Name.getName().getNameKind()) { 1186 case clang::DeclarationName::Identifier: 1187 case clang::DeclarationName::CXXLiteralOperatorName: 1188 case clang::DeclarationName::CXXOperatorName: 1189 case clang::DeclarationName::CXXUsingDirective: 1190 return false; 1191 1192 case clang::DeclarationName::CXXConstructorName: 1193 case clang::DeclarationName::CXXDestructorName: 1194 case clang::DeclarationName::CXXConversionFunctionName: 1195 if (TypeSourceInfo *TSInfo = Name.getNamedTypeInfo()) 1196 return Visit(TSInfo->getTypeLoc()); 1197 return false; 1198 1199 case clang::DeclarationName::ObjCZeroArgSelector: 1200 case clang::DeclarationName::ObjCOneArgSelector: 1201 case clang::DeclarationName::ObjCMultiArgSelector: 1202 // FIXME: Per-identifier location info? 1203 return false; 1204 } 1205 1206 return false; 1207} 1208 1209bool CursorVisitor::VisitNestedNameSpecifier(NestedNameSpecifier *NNS, 1210 SourceRange Range) { 1211 // FIXME: This whole routine is a hack to work around the lack of proper 1212 // source information in nested-name-specifiers (PR5791). Since we do have 1213 // a beginning source location, we can visit the first component of the 1214 // nested-name-specifier, if it's a single-token component. 1215 if (!NNS) 1216 return false; 1217 1218 // Get the first component in the nested-name-specifier. 1219 while (NestedNameSpecifier *Prefix = NNS->getPrefix()) 1220 NNS = Prefix; 1221 1222 switch (NNS->getKind()) { 1223 case NestedNameSpecifier::Namespace: 1224 return Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), Range.getBegin(), 1225 TU)); 1226 1227 case NestedNameSpecifier::NamespaceAlias: 1228 return Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(), 1229 Range.getBegin(), TU)); 1230 1231 case NestedNameSpecifier::TypeSpec: { 1232 // If the type has a form where we know that the beginning of the source 1233 // range matches up with a reference cursor. Visit the appropriate reference 1234 // cursor. 1235 const Type *T = NNS->getAsType(); 1236 if (const TypedefType *Typedef = dyn_cast<TypedefType>(T)) 1237 return Visit(MakeCursorTypeRef(Typedef->getDecl(), Range.getBegin(), TU)); 1238 if (const TagType *Tag = dyn_cast<TagType>(T)) 1239 return Visit(MakeCursorTypeRef(Tag->getDecl(), Range.getBegin(), TU)); 1240 if (const TemplateSpecializationType *TST 1241 = dyn_cast<TemplateSpecializationType>(T)) 1242 return VisitTemplateName(TST->getTemplateName(), Range.getBegin()); 1243 break; 1244 } 1245 1246 case NestedNameSpecifier::TypeSpecWithTemplate: 1247 case NestedNameSpecifier::Global: 1248 case NestedNameSpecifier::Identifier: 1249 break; 1250 } 1251 1252 return false; 1253} 1254 1255bool 1256CursorVisitor::VisitNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) { 1257 llvm::SmallVector<NestedNameSpecifierLoc, 4> Qualifiers; 1258 for (; Qualifier; Qualifier = Qualifier.getPrefix()) 1259 Qualifiers.push_back(Qualifier); 1260 1261 while (!Qualifiers.empty()) { 1262 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val(); 1263 NestedNameSpecifier *NNS = Q.getNestedNameSpecifier(); 1264 switch (NNS->getKind()) { 1265 case NestedNameSpecifier::Namespace: 1266 if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), 1267 Q.getLocalBeginLoc(), 1268 TU))) 1269 return true; 1270 1271 break; 1272 1273 case NestedNameSpecifier::NamespaceAlias: 1274 if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(), 1275 Q.getLocalBeginLoc(), 1276 TU))) 1277 return true; 1278 1279 break; 1280 1281 case NestedNameSpecifier::TypeSpec: 1282 case NestedNameSpecifier::TypeSpecWithTemplate: 1283 if (Visit(Q.getTypeLoc())) 1284 return true; 1285 1286 break; 1287 1288 case NestedNameSpecifier::Global: 1289 case NestedNameSpecifier::Identifier: 1290 break; 1291 } 1292 } 1293 1294 return false; 1295} 1296 1297bool CursorVisitor::VisitTemplateParameters( 1298 const TemplateParameterList *Params) { 1299 if (!Params) 1300 return false; 1301 1302 for (TemplateParameterList::const_iterator P = Params->begin(), 1303 PEnd = Params->end(); 1304 P != PEnd; ++P) { 1305 if (Visit(MakeCXCursor(*P, TU))) 1306 return true; 1307 } 1308 1309 return false; 1310} 1311 1312bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) { 1313 switch (Name.getKind()) { 1314 case TemplateName::Template: 1315 return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU)); 1316 1317 case TemplateName::OverloadedTemplate: 1318 // Visit the overloaded template set. 1319 if (Visit(MakeCursorOverloadedDeclRef(Name, Loc, TU))) 1320 return true; 1321 1322 return false; 1323 1324 case TemplateName::DependentTemplate: 1325 // FIXME: Visit nested-name-specifier. 1326 return false; 1327 1328 case TemplateName::QualifiedTemplate: 1329 // FIXME: Visit nested-name-specifier. 1330 return Visit(MakeCursorTemplateRef( 1331 Name.getAsQualifiedTemplateName()->getDecl(), 1332 Loc, TU)); 1333 1334 case TemplateName::SubstTemplateTemplateParm: 1335 return Visit(MakeCursorTemplateRef( 1336 Name.getAsSubstTemplateTemplateParm()->getParameter(), 1337 Loc, TU)); 1338 1339 case TemplateName::SubstTemplateTemplateParmPack: 1340 return Visit(MakeCursorTemplateRef( 1341 Name.getAsSubstTemplateTemplateParmPack()->getParameterPack(), 1342 Loc, TU)); 1343 } 1344 1345 return false; 1346} 1347 1348bool CursorVisitor::VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL) { 1349 switch (TAL.getArgument().getKind()) { 1350 case TemplateArgument::Null: 1351 case TemplateArgument::Integral: 1352 case TemplateArgument::Pack: 1353 return false; 1354 1355 case TemplateArgument::Type: 1356 if (TypeSourceInfo *TSInfo = TAL.getTypeSourceInfo()) 1357 return Visit(TSInfo->getTypeLoc()); 1358 return false; 1359 1360 case TemplateArgument::Declaration: 1361 if (Expr *E = TAL.getSourceDeclExpression()) 1362 return Visit(MakeCXCursor(E, StmtParent, TU)); 1363 return false; 1364 1365 case TemplateArgument::Expression: 1366 if (Expr *E = TAL.getSourceExpression()) 1367 return Visit(MakeCXCursor(E, StmtParent, TU)); 1368 return false; 1369 1370 case TemplateArgument::Template: 1371 case TemplateArgument::TemplateExpansion: 1372 if (VisitNestedNameSpecifierLoc(TAL.getTemplateQualifierLoc())) 1373 return true; 1374 1375 return VisitTemplateName(TAL.getArgument().getAsTemplateOrTemplatePattern(), 1376 TAL.getTemplateNameLoc()); 1377 } 1378 1379 return false; 1380} 1381 1382bool CursorVisitor::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 1383 return VisitDeclContext(D); 1384} 1385 1386bool CursorVisitor::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 1387 return Visit(TL.getUnqualifiedLoc()); 1388} 1389 1390bool CursorVisitor::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 1391 ASTContext &Context = AU->getASTContext(); 1392 1393 // Some builtin types (such as Objective-C's "id", "sel", and 1394 // "Class") have associated declarations. Create cursors for those. 1395 QualType VisitType; 1396 switch (TL.getType()->getAs<BuiltinType>()->getKind()) { 1397 case BuiltinType::Void: 1398 case BuiltinType::Bool: 1399 case BuiltinType::Char_U: 1400 case BuiltinType::UChar: 1401 case BuiltinType::Char16: 1402 case BuiltinType::Char32: 1403 case BuiltinType::UShort: 1404 case BuiltinType::UInt: 1405 case BuiltinType::ULong: 1406 case BuiltinType::ULongLong: 1407 case BuiltinType::UInt128: 1408 case BuiltinType::Char_S: 1409 case BuiltinType::SChar: 1410 case BuiltinType::WChar_U: 1411 case BuiltinType::WChar_S: 1412 case BuiltinType::Short: 1413 case BuiltinType::Int: 1414 case BuiltinType::Long: 1415 case BuiltinType::LongLong: 1416 case BuiltinType::Int128: 1417 case BuiltinType::Float: 1418 case BuiltinType::Double: 1419 case BuiltinType::LongDouble: 1420 case BuiltinType::NullPtr: 1421 case BuiltinType::Overload: 1422 case BuiltinType::BoundMember: 1423 case BuiltinType::Dependent: 1424 case BuiltinType::UnknownAny: 1425 break; 1426 1427 case BuiltinType::ObjCId: 1428 VisitType = Context.getObjCIdType(); 1429 break; 1430 1431 case BuiltinType::ObjCClass: 1432 VisitType = Context.getObjCClassType(); 1433 break; 1434 1435 case BuiltinType::ObjCSel: 1436 VisitType = Context.getObjCSelType(); 1437 break; 1438 } 1439 1440 if (!VisitType.isNull()) { 1441 if (const TypedefType *Typedef = VisitType->getAs<TypedefType>()) 1442 return Visit(MakeCursorTypeRef(Typedef->getDecl(), TL.getBuiltinLoc(), 1443 TU)); 1444 } 1445 1446 return false; 1447} 1448 1449bool CursorVisitor::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 1450 return Visit(MakeCursorTypeRef(TL.getTypedefNameDecl(), TL.getNameLoc(), TU)); 1451} 1452 1453bool CursorVisitor::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 1454 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1455} 1456 1457bool CursorVisitor::VisitTagTypeLoc(TagTypeLoc TL) { 1458 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1459} 1460 1461bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 1462 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1463} 1464 1465bool CursorVisitor::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 1466 if (Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU))) 1467 return true; 1468 1469 return false; 1470} 1471 1472bool CursorVisitor::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 1473 if (TL.hasBaseTypeAsWritten() && Visit(TL.getBaseLoc())) 1474 return true; 1475 1476 for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) { 1477 if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I), 1478 TU))) 1479 return true; 1480 } 1481 1482 return false; 1483} 1484 1485bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 1486 return Visit(TL.getPointeeLoc()); 1487} 1488 1489bool CursorVisitor::VisitParenTypeLoc(ParenTypeLoc TL) { 1490 return Visit(TL.getInnerLoc()); 1491} 1492 1493bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) { 1494 return Visit(TL.getPointeeLoc()); 1495} 1496 1497bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 1498 return Visit(TL.getPointeeLoc()); 1499} 1500 1501bool CursorVisitor::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 1502 return Visit(TL.getPointeeLoc()); 1503} 1504 1505bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 1506 return Visit(TL.getPointeeLoc()); 1507} 1508 1509bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 1510 return Visit(TL.getPointeeLoc()); 1511} 1512 1513bool CursorVisitor::VisitFunctionTypeLoc(FunctionTypeLoc TL, 1514 bool SkipResultType) { 1515 if (!SkipResultType && Visit(TL.getResultLoc())) 1516 return true; 1517 1518 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1519 if (Decl *D = TL.getArg(I)) 1520 if (Visit(MakeCXCursor(D, TU))) 1521 return true; 1522 1523 return false; 1524} 1525 1526bool CursorVisitor::VisitArrayTypeLoc(ArrayTypeLoc TL) { 1527 if (Visit(TL.getElementLoc())) 1528 return true; 1529 1530 if (Expr *Size = TL.getSizeExpr()) 1531 return Visit(MakeCXCursor(Size, StmtParent, TU)); 1532 1533 return false; 1534} 1535 1536bool CursorVisitor::VisitTemplateSpecializationTypeLoc( 1537 TemplateSpecializationTypeLoc TL) { 1538 // Visit the template name. 1539 if (VisitTemplateName(TL.getTypePtr()->getTemplateName(), 1540 TL.getTemplateNameLoc())) 1541 return true; 1542 1543 // Visit the template arguments. 1544 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1545 if (VisitTemplateArgumentLoc(TL.getArgLoc(I))) 1546 return true; 1547 1548 return false; 1549} 1550 1551bool CursorVisitor::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 1552 return Visit(MakeCXCursor(TL.getUnderlyingExpr(), StmtParent, TU)); 1553} 1554 1555bool CursorVisitor::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 1556 if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo()) 1557 return Visit(TSInfo->getTypeLoc()); 1558 1559 return false; 1560} 1561 1562bool CursorVisitor::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 1563 if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo()) 1564 return Visit(TSInfo->getTypeLoc()); 1565 1566 return false; 1567} 1568 1569bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 1570 if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1571 return true; 1572 1573 return false; 1574} 1575 1576bool CursorVisitor::VisitDependentTemplateSpecializationTypeLoc( 1577 DependentTemplateSpecializationTypeLoc TL) { 1578 // Visit the nested-name-specifier, if there is one. 1579 if (TL.getQualifierLoc() && 1580 VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1581 return true; 1582 1583 // Visit the template arguments. 1584 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1585 if (VisitTemplateArgumentLoc(TL.getArgLoc(I))) 1586 return true; 1587 1588 return false; 1589} 1590 1591bool CursorVisitor::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 1592 if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1593 return true; 1594 1595 return Visit(TL.getNamedTypeLoc()); 1596} 1597 1598bool CursorVisitor::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 1599 return Visit(TL.getPatternLoc()); 1600} 1601 1602bool CursorVisitor::VisitCXXRecordDecl(CXXRecordDecl *D) { 1603 // Visit the nested-name-specifier, if present. 1604 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1605 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1606 return true; 1607 1608 if (D->isDefinition()) { 1609 for (CXXRecordDecl::base_class_iterator I = D->bases_begin(), 1610 E = D->bases_end(); I != E; ++I) { 1611 if (Visit(cxcursor::MakeCursorCXXBaseSpecifier(I, TU))) 1612 return true; 1613 } 1614 } 1615 1616 return VisitTagDecl(D); 1617} 1618 1619bool CursorVisitor::VisitAttributes(Decl *D) { 1620 for (AttrVec::const_iterator i = D->attr_begin(), e = D->attr_end(); 1621 i != e; ++i) 1622 if (Visit(MakeCXCursor(*i, D, TU))) 1623 return true; 1624 1625 return false; 1626} 1627 1628//===----------------------------------------------------------------------===// 1629// Data-recursive visitor methods. 1630//===----------------------------------------------------------------------===// 1631 1632namespace { 1633#define DEF_JOB(NAME, DATA, KIND)\ 1634class NAME : public VisitorJob {\ 1635public:\ 1636 NAME(DATA *d, CXCursor parent) : VisitorJob(parent, VisitorJob::KIND, d) {} \ 1637 static bool classof(const VisitorJob *VJ) { return VJ->getKind() == KIND; }\ 1638 DATA *get() const { return static_cast<DATA*>(data[0]); }\ 1639}; 1640 1641DEF_JOB(StmtVisit, Stmt, StmtVisitKind) 1642DEF_JOB(MemberExprParts, MemberExpr, MemberExprPartsKind) 1643DEF_JOB(DeclRefExprParts, DeclRefExpr, DeclRefExprPartsKind) 1644DEF_JOB(OverloadExprParts, OverloadExpr, OverloadExprPartsKind) 1645DEF_JOB(ExplicitTemplateArgsVisit, ExplicitTemplateArgumentList, 1646 ExplicitTemplateArgsVisitKind) 1647DEF_JOB(SizeOfPackExprParts, SizeOfPackExpr, SizeOfPackExprPartsKind) 1648#undef DEF_JOB 1649 1650class DeclVisit : public VisitorJob { 1651public: 1652 DeclVisit(Decl *d, CXCursor parent, bool isFirst) : 1653 VisitorJob(parent, VisitorJob::DeclVisitKind, 1654 d, isFirst ? (void*) 1 : (void*) 0) {} 1655 static bool classof(const VisitorJob *VJ) { 1656 return VJ->getKind() == DeclVisitKind; 1657 } 1658 Decl *get() const { return static_cast<Decl*>(data[0]); } 1659 bool isFirst() const { return data[1] ? true : false; } 1660}; 1661class TypeLocVisit : public VisitorJob { 1662public: 1663 TypeLocVisit(TypeLoc tl, CXCursor parent) : 1664 VisitorJob(parent, VisitorJob::TypeLocVisitKind, 1665 tl.getType().getAsOpaquePtr(), tl.getOpaqueData()) {} 1666 1667 static bool classof(const VisitorJob *VJ) { 1668 return VJ->getKind() == TypeLocVisitKind; 1669 } 1670 1671 TypeLoc get() const { 1672 QualType T = QualType::getFromOpaquePtr(data[0]); 1673 return TypeLoc(T, data[1]); 1674 } 1675}; 1676 1677class LabelRefVisit : public VisitorJob { 1678public: 1679 LabelRefVisit(LabelDecl *LD, SourceLocation labelLoc, CXCursor parent) 1680 : VisitorJob(parent, VisitorJob::LabelRefVisitKind, LD, 1681 labelLoc.getPtrEncoding()) {} 1682 1683 static bool classof(const VisitorJob *VJ) { 1684 return VJ->getKind() == VisitorJob::LabelRefVisitKind; 1685 } 1686 LabelDecl *get() const { return static_cast<LabelDecl*>(data[0]); } 1687 SourceLocation getLoc() const { 1688 return SourceLocation::getFromPtrEncoding(data[1]); } 1689}; 1690class NestedNameSpecifierVisit : public VisitorJob { 1691public: 1692 NestedNameSpecifierVisit(NestedNameSpecifier *NS, SourceRange R, 1693 CXCursor parent) 1694 : VisitorJob(parent, VisitorJob::NestedNameSpecifierVisitKind, 1695 NS, R.getBegin().getPtrEncoding(), 1696 R.getEnd().getPtrEncoding()) {} 1697 static bool classof(const VisitorJob *VJ) { 1698 return VJ->getKind() == VisitorJob::NestedNameSpecifierVisitKind; 1699 } 1700 NestedNameSpecifier *get() const { 1701 return static_cast<NestedNameSpecifier*>(data[0]); 1702 } 1703 SourceRange getSourceRange() const { 1704 SourceLocation A = 1705 SourceLocation::getFromRawEncoding((unsigned)(uintptr_t) data[1]); 1706 SourceLocation B = 1707 SourceLocation::getFromRawEncoding((unsigned)(uintptr_t) data[2]); 1708 return SourceRange(A, B); 1709 } 1710}; 1711 1712class NestedNameSpecifierLocVisit : public VisitorJob { 1713public: 1714 NestedNameSpecifierLocVisit(NestedNameSpecifierLoc Qualifier, CXCursor parent) 1715 : VisitorJob(parent, VisitorJob::NestedNameSpecifierLocVisitKind, 1716 Qualifier.getNestedNameSpecifier(), 1717 Qualifier.getOpaqueData()) { } 1718 1719 static bool classof(const VisitorJob *VJ) { 1720 return VJ->getKind() == VisitorJob::NestedNameSpecifierLocVisitKind; 1721 } 1722 1723 NestedNameSpecifierLoc get() const { 1724 return NestedNameSpecifierLoc(static_cast<NestedNameSpecifier*>(data[0]), 1725 data[1]); 1726 } 1727}; 1728 1729class DeclarationNameInfoVisit : public VisitorJob { 1730public: 1731 DeclarationNameInfoVisit(Stmt *S, CXCursor parent) 1732 : VisitorJob(parent, VisitorJob::DeclarationNameInfoVisitKind, S) {} 1733 static bool classof(const VisitorJob *VJ) { 1734 return VJ->getKind() == VisitorJob::DeclarationNameInfoVisitKind; 1735 } 1736 DeclarationNameInfo get() const { 1737 Stmt *S = static_cast<Stmt*>(data[0]); 1738 switch (S->getStmtClass()) { 1739 default: 1740 llvm_unreachable("Unhandled Stmt"); 1741 case Stmt::CXXDependentScopeMemberExprClass: 1742 return cast<CXXDependentScopeMemberExpr>(S)->getMemberNameInfo(); 1743 case Stmt::DependentScopeDeclRefExprClass: 1744 return cast<DependentScopeDeclRefExpr>(S)->getNameInfo(); 1745 } 1746 } 1747}; 1748class MemberRefVisit : public VisitorJob { 1749public: 1750 MemberRefVisit(FieldDecl *D, SourceLocation L, CXCursor parent) 1751 : VisitorJob(parent, VisitorJob::MemberRefVisitKind, D, 1752 L.getPtrEncoding()) {} 1753 static bool classof(const VisitorJob *VJ) { 1754 return VJ->getKind() == VisitorJob::MemberRefVisitKind; 1755 } 1756 FieldDecl *get() const { 1757 return static_cast<FieldDecl*>(data[0]); 1758 } 1759 SourceLocation getLoc() const { 1760 return SourceLocation::getFromRawEncoding((unsigned)(uintptr_t) data[1]); 1761 } 1762}; 1763class EnqueueVisitor : public StmtVisitor<EnqueueVisitor, void> { 1764 VisitorWorkList &WL; 1765 CXCursor Parent; 1766public: 1767 EnqueueVisitor(VisitorWorkList &wl, CXCursor parent) 1768 : WL(wl), Parent(parent) {} 1769 1770 void VisitAddrLabelExpr(AddrLabelExpr *E); 1771 void VisitBlockExpr(BlockExpr *B); 1772 void VisitCompoundLiteralExpr(CompoundLiteralExpr *E); 1773 void VisitCompoundStmt(CompoundStmt *S); 1774 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { /* Do nothing. */ } 1775 void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E); 1776 void VisitCXXNewExpr(CXXNewExpr *E); 1777 void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E); 1778 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E); 1779 void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E); 1780 void VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E); 1781 void VisitCXXTypeidExpr(CXXTypeidExpr *E); 1782 void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E); 1783 void VisitCXXUuidofExpr(CXXUuidofExpr *E); 1784 void VisitDeclRefExpr(DeclRefExpr *D); 1785 void VisitDeclStmt(DeclStmt *S); 1786 void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E); 1787 void VisitDesignatedInitExpr(DesignatedInitExpr *E); 1788 void VisitExplicitCastExpr(ExplicitCastExpr *E); 1789 void VisitForStmt(ForStmt *FS); 1790 void VisitGotoStmt(GotoStmt *GS); 1791 void VisitIfStmt(IfStmt *If); 1792 void VisitInitListExpr(InitListExpr *IE); 1793 void VisitMemberExpr(MemberExpr *M); 1794 void VisitOffsetOfExpr(OffsetOfExpr *E); 1795 void VisitObjCEncodeExpr(ObjCEncodeExpr *E); 1796 void VisitObjCMessageExpr(ObjCMessageExpr *M); 1797 void VisitOverloadExpr(OverloadExpr *E); 1798 void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E); 1799 void VisitStmt(Stmt *S); 1800 void VisitSwitchStmt(SwitchStmt *S); 1801 void VisitWhileStmt(WhileStmt *W); 1802 void VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E); 1803 void VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E); 1804 void VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E); 1805 void VisitExpressionTraitExpr(ExpressionTraitExpr *E); 1806 void VisitUnresolvedMemberExpr(UnresolvedMemberExpr *U); 1807 void VisitVAArgExpr(VAArgExpr *E); 1808 void VisitSizeOfPackExpr(SizeOfPackExpr *E); 1809 1810private: 1811 void AddDeclarationNameInfo(Stmt *S); 1812 void AddNestedNameSpecifier(NestedNameSpecifier *NS, SourceRange R); 1813 void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier); 1814 void AddExplicitTemplateArgs(const ExplicitTemplateArgumentList *A); 1815 void AddMemberRef(FieldDecl *D, SourceLocation L); 1816 void AddStmt(Stmt *S); 1817 void AddDecl(Decl *D, bool isFirst = true); 1818 void AddTypeLoc(TypeSourceInfo *TI); 1819 void EnqueueChildren(Stmt *S); 1820}; 1821} // end anonyous namespace 1822 1823void EnqueueVisitor::AddDeclarationNameInfo(Stmt *S) { 1824 // 'S' should always be non-null, since it comes from the 1825 // statement we are visiting. 1826 WL.push_back(DeclarationNameInfoVisit(S, Parent)); 1827} 1828void EnqueueVisitor::AddNestedNameSpecifier(NestedNameSpecifier *N, 1829 SourceRange R) { 1830 if (N) 1831 WL.push_back(NestedNameSpecifierVisit(N, R, Parent)); 1832} 1833 1834void 1835EnqueueVisitor::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) { 1836 if (Qualifier) 1837 WL.push_back(NestedNameSpecifierLocVisit(Qualifier, Parent)); 1838} 1839 1840void EnqueueVisitor::AddStmt(Stmt *S) { 1841 if (S) 1842 WL.push_back(StmtVisit(S, Parent)); 1843} 1844void EnqueueVisitor::AddDecl(Decl *D, bool isFirst) { 1845 if (D) 1846 WL.push_back(DeclVisit(D, Parent, isFirst)); 1847} 1848void EnqueueVisitor:: 1849 AddExplicitTemplateArgs(const ExplicitTemplateArgumentList *A) { 1850 if (A) 1851 WL.push_back(ExplicitTemplateArgsVisit( 1852 const_cast<ExplicitTemplateArgumentList*>(A), Parent)); 1853} 1854void EnqueueVisitor::AddMemberRef(FieldDecl *D, SourceLocation L) { 1855 if (D) 1856 WL.push_back(MemberRefVisit(D, L, Parent)); 1857} 1858void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) { 1859 if (TI) 1860 WL.push_back(TypeLocVisit(TI->getTypeLoc(), Parent)); 1861 } 1862void EnqueueVisitor::EnqueueChildren(Stmt *S) { 1863 unsigned size = WL.size(); 1864 for (Stmt::child_range Child = S->children(); Child; ++Child) { 1865 AddStmt(*Child); 1866 } 1867 if (size == WL.size()) 1868 return; 1869 // Now reverse the entries we just added. This will match the DFS 1870 // ordering performed by the worklist. 1871 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 1872 std::reverse(I, E); 1873} 1874void EnqueueVisitor::VisitAddrLabelExpr(AddrLabelExpr *E) { 1875 WL.push_back(LabelRefVisit(E->getLabel(), E->getLabelLoc(), Parent)); 1876} 1877void EnqueueVisitor::VisitBlockExpr(BlockExpr *B) { 1878 AddDecl(B->getBlockDecl()); 1879} 1880void EnqueueVisitor::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 1881 EnqueueChildren(E); 1882 AddTypeLoc(E->getTypeSourceInfo()); 1883} 1884void EnqueueVisitor::VisitCompoundStmt(CompoundStmt *S) { 1885 for (CompoundStmt::reverse_body_iterator I = S->body_rbegin(), 1886 E = S->body_rend(); I != E; ++I) { 1887 AddStmt(*I); 1888 } 1889} 1890void EnqueueVisitor:: 1891VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) { 1892 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 1893 AddDeclarationNameInfo(E); 1894 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc()) 1895 AddNestedNameSpecifierLoc(QualifierLoc); 1896 if (!E->isImplicitAccess()) 1897 AddStmt(E->getBase()); 1898} 1899void EnqueueVisitor::VisitCXXNewExpr(CXXNewExpr *E) { 1900 // Enqueue the initializer or constructor arguments. 1901 for (unsigned I = E->getNumConstructorArgs(); I > 0; --I) 1902 AddStmt(E->getConstructorArg(I-1)); 1903 // Enqueue the array size, if any. 1904 AddStmt(E->getArraySize()); 1905 // Enqueue the allocated type. 1906 AddTypeLoc(E->getAllocatedTypeSourceInfo()); 1907 // Enqueue the placement arguments. 1908 for (unsigned I = E->getNumPlacementArgs(); I > 0; --I) 1909 AddStmt(E->getPlacementArg(I-1)); 1910} 1911void EnqueueVisitor::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *CE) { 1912 for (unsigned I = CE->getNumArgs(); I > 1 /* Yes, this is 1 */; --I) 1913 AddStmt(CE->getArg(I-1)); 1914 AddStmt(CE->getCallee()); 1915 AddStmt(CE->getArg(0)); 1916} 1917void EnqueueVisitor::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 1918 // Visit the name of the type being destroyed. 1919 AddTypeLoc(E->getDestroyedTypeInfo()); 1920 // Visit the scope type that looks disturbingly like the nested-name-specifier 1921 // but isn't. 1922 AddTypeLoc(E->getScopeTypeInfo()); 1923 // Visit the nested-name-specifier. 1924 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc()) 1925 AddNestedNameSpecifierLoc(QualifierLoc); 1926 // Visit base expression. 1927 AddStmt(E->getBase()); 1928} 1929void EnqueueVisitor::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 1930 AddTypeLoc(E->getTypeSourceInfo()); 1931} 1932void EnqueueVisitor::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { 1933 EnqueueChildren(E); 1934 AddTypeLoc(E->getTypeSourceInfo()); 1935} 1936void EnqueueVisitor::VisitCXXTypeidExpr(CXXTypeidExpr *E) { 1937 EnqueueChildren(E); 1938 if (E->isTypeOperand()) 1939 AddTypeLoc(E->getTypeOperandSourceInfo()); 1940} 1941 1942void EnqueueVisitor::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr 1943 *E) { 1944 EnqueueChildren(E); 1945 AddTypeLoc(E->getTypeSourceInfo()); 1946} 1947void EnqueueVisitor::VisitCXXUuidofExpr(CXXUuidofExpr *E) { 1948 EnqueueChildren(E); 1949 if (E->isTypeOperand()) 1950 AddTypeLoc(E->getTypeOperandSourceInfo()); 1951} 1952void EnqueueVisitor::VisitDeclRefExpr(DeclRefExpr *DR) { 1953 if (DR->hasExplicitTemplateArgs()) { 1954 AddExplicitTemplateArgs(&DR->getExplicitTemplateArgs()); 1955 } 1956 WL.push_back(DeclRefExprParts(DR, Parent)); 1957} 1958void EnqueueVisitor::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 1959 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 1960 AddDeclarationNameInfo(E); 1961 AddNestedNameSpecifierLoc(E->getQualifierLoc()); 1962} 1963void EnqueueVisitor::VisitDeclStmt(DeclStmt *S) { 1964 unsigned size = WL.size(); 1965 bool isFirst = true; 1966 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 1967 D != DEnd; ++D) { 1968 AddDecl(*D, isFirst); 1969 isFirst = false; 1970 } 1971 if (size == WL.size()) 1972 return; 1973 // Now reverse the entries we just added. This will match the DFS 1974 // ordering performed by the worklist. 1975 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 1976 std::reverse(I, E); 1977} 1978void EnqueueVisitor::VisitDesignatedInitExpr(DesignatedInitExpr *E) { 1979 AddStmt(E->getInit()); 1980 typedef DesignatedInitExpr::Designator Designator; 1981 for (DesignatedInitExpr::reverse_designators_iterator 1982 D = E->designators_rbegin(), DEnd = E->designators_rend(); 1983 D != DEnd; ++D) { 1984 if (D->isFieldDesignator()) { 1985 if (FieldDecl *Field = D->getField()) 1986 AddMemberRef(Field, D->getFieldLoc()); 1987 continue; 1988 } 1989 if (D->isArrayDesignator()) { 1990 AddStmt(E->getArrayIndex(*D)); 1991 continue; 1992 } 1993 assert(D->isArrayRangeDesignator() && "Unknown designator kind"); 1994 AddStmt(E->getArrayRangeEnd(*D)); 1995 AddStmt(E->getArrayRangeStart(*D)); 1996 } 1997} 1998void EnqueueVisitor::VisitExplicitCastExpr(ExplicitCastExpr *E) { 1999 EnqueueChildren(E); 2000 AddTypeLoc(E->getTypeInfoAsWritten()); 2001} 2002void EnqueueVisitor::VisitForStmt(ForStmt *FS) { 2003 AddStmt(FS->getBody()); 2004 AddStmt(FS->getInc()); 2005 AddStmt(FS->getCond()); 2006 AddDecl(FS->getConditionVariable()); 2007 AddStmt(FS->getInit()); 2008} 2009void EnqueueVisitor::VisitGotoStmt(GotoStmt *GS) { 2010 WL.push_back(LabelRefVisit(GS->getLabel(), GS->getLabelLoc(), Parent)); 2011} 2012void EnqueueVisitor::VisitIfStmt(IfStmt *If) { 2013 AddStmt(If->getElse()); 2014 AddStmt(If->getThen()); 2015 AddStmt(If->getCond()); 2016 AddDecl(If->getConditionVariable()); 2017} 2018void EnqueueVisitor::VisitInitListExpr(InitListExpr *IE) { 2019 // We care about the syntactic form of the initializer list, only. 2020 if (InitListExpr *Syntactic = IE->getSyntacticForm()) 2021 IE = Syntactic; 2022 EnqueueChildren(IE); 2023} 2024void EnqueueVisitor::VisitMemberExpr(MemberExpr *M) { 2025 WL.push_back(MemberExprParts(M, Parent)); 2026 2027 // If the base of the member access expression is an implicit 'this', don't 2028 // visit it. 2029 // FIXME: If we ever want to show these implicit accesses, this will be 2030 // unfortunate. However, clang_getCursor() relies on this behavior. 2031 if (!M->isImplicitAccess()) 2032 AddStmt(M->getBase()); 2033} 2034void EnqueueVisitor::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 2035 AddTypeLoc(E->getEncodedTypeSourceInfo()); 2036} 2037void EnqueueVisitor::VisitObjCMessageExpr(ObjCMessageExpr *M) { 2038 EnqueueChildren(M); 2039 AddTypeLoc(M->getClassReceiverTypeInfo()); 2040} 2041void EnqueueVisitor::VisitOffsetOfExpr(OffsetOfExpr *E) { 2042 // Visit the components of the offsetof expression. 2043 for (unsigned N = E->getNumComponents(), I = N; I > 0; --I) { 2044 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode; 2045 const OffsetOfNode &Node = E->getComponent(I-1); 2046 switch (Node.getKind()) { 2047 case OffsetOfNode::Array: 2048 AddStmt(E->getIndexExpr(Node.getArrayExprIndex())); 2049 break; 2050 case OffsetOfNode::Field: 2051 AddMemberRef(Node.getField(), Node.getSourceRange().getEnd()); 2052 break; 2053 case OffsetOfNode::Identifier: 2054 case OffsetOfNode::Base: 2055 continue; 2056 } 2057 } 2058 // Visit the type into which we're computing the offset. 2059 AddTypeLoc(E->getTypeSourceInfo()); 2060} 2061void EnqueueVisitor::VisitOverloadExpr(OverloadExpr *E) { 2062 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 2063 WL.push_back(OverloadExprParts(E, Parent)); 2064} 2065void EnqueueVisitor::VisitUnaryExprOrTypeTraitExpr( 2066 UnaryExprOrTypeTraitExpr *E) { 2067 EnqueueChildren(E); 2068 if (E->isArgumentType()) 2069 AddTypeLoc(E->getArgumentTypeInfo()); 2070} 2071void EnqueueVisitor::VisitStmt(Stmt *S) { 2072 EnqueueChildren(S); 2073} 2074void EnqueueVisitor::VisitSwitchStmt(SwitchStmt *S) { 2075 AddStmt(S->getBody()); 2076 AddStmt(S->getCond()); 2077 AddDecl(S->getConditionVariable()); 2078} 2079 2080void EnqueueVisitor::VisitWhileStmt(WhileStmt *W) { 2081 AddStmt(W->getBody()); 2082 AddStmt(W->getCond()); 2083 AddDecl(W->getConditionVariable()); 2084} 2085 2086void EnqueueVisitor::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 2087 AddTypeLoc(E->getQueriedTypeSourceInfo()); 2088} 2089 2090void EnqueueVisitor::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) { 2091 AddTypeLoc(E->getRhsTypeSourceInfo()); 2092 AddTypeLoc(E->getLhsTypeSourceInfo()); 2093} 2094 2095void EnqueueVisitor::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 2096 AddTypeLoc(E->getQueriedTypeSourceInfo()); 2097} 2098 2099void EnqueueVisitor::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 2100 EnqueueChildren(E); 2101} 2102 2103void EnqueueVisitor::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *U) { 2104 VisitOverloadExpr(U); 2105 if (!U->isImplicitAccess()) 2106 AddStmt(U->getBase()); 2107} 2108void EnqueueVisitor::VisitVAArgExpr(VAArgExpr *E) { 2109 AddStmt(E->getSubExpr()); 2110 AddTypeLoc(E->getWrittenTypeInfo()); 2111} 2112void EnqueueVisitor::VisitSizeOfPackExpr(SizeOfPackExpr *E) { 2113 WL.push_back(SizeOfPackExprParts(E, Parent)); 2114} 2115 2116void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, Stmt *S) { 2117 EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU)).Visit(S); 2118} 2119 2120bool CursorVisitor::IsInRegionOfInterest(CXCursor C) { 2121 if (RegionOfInterest.isValid()) { 2122 SourceRange Range = getRawCursorExtent(C); 2123 if (Range.isInvalid() || CompareRegionOfInterest(Range)) 2124 return false; 2125 } 2126 return true; 2127} 2128 2129bool CursorVisitor::RunVisitorWorkList(VisitorWorkList &WL) { 2130 while (!WL.empty()) { 2131 // Dequeue the worklist item. 2132 VisitorJob LI = WL.back(); 2133 WL.pop_back(); 2134 2135 // Set the Parent field, then back to its old value once we're done. 2136 SetParentRAII SetParent(Parent, StmtParent, LI.getParent()); 2137 2138 switch (LI.getKind()) { 2139 case VisitorJob::DeclVisitKind: { 2140 Decl *D = cast<DeclVisit>(&LI)->get(); 2141 if (!D) 2142 continue; 2143 2144 // For now, perform default visitation for Decls. 2145 if (Visit(MakeCXCursor(D, TU, cast<DeclVisit>(&LI)->isFirst()))) 2146 return true; 2147 2148 continue; 2149 } 2150 case VisitorJob::ExplicitTemplateArgsVisitKind: { 2151 const ExplicitTemplateArgumentList *ArgList = 2152 cast<ExplicitTemplateArgsVisit>(&LI)->get(); 2153 for (const TemplateArgumentLoc *Arg = ArgList->getTemplateArgs(), 2154 *ArgEnd = Arg + ArgList->NumTemplateArgs; 2155 Arg != ArgEnd; ++Arg) { 2156 if (VisitTemplateArgumentLoc(*Arg)) 2157 return true; 2158 } 2159 continue; 2160 } 2161 case VisitorJob::TypeLocVisitKind: { 2162 // Perform default visitation for TypeLocs. 2163 if (Visit(cast<TypeLocVisit>(&LI)->get())) 2164 return true; 2165 continue; 2166 } 2167 case VisitorJob::LabelRefVisitKind: { 2168 LabelDecl *LS = cast<LabelRefVisit>(&LI)->get(); 2169 if (LabelStmt *stmt = LS->getStmt()) { 2170 if (Visit(MakeCursorLabelRef(stmt, cast<LabelRefVisit>(&LI)->getLoc(), 2171 TU))) { 2172 return true; 2173 } 2174 } 2175 continue; 2176 } 2177 2178 case VisitorJob::NestedNameSpecifierVisitKind: { 2179 NestedNameSpecifierVisit *V = cast<NestedNameSpecifierVisit>(&LI); 2180 if (VisitNestedNameSpecifier(V->get(), V->getSourceRange())) 2181 return true; 2182 continue; 2183 } 2184 2185 case VisitorJob::NestedNameSpecifierLocVisitKind: { 2186 NestedNameSpecifierLocVisit *V = cast<NestedNameSpecifierLocVisit>(&LI); 2187 if (VisitNestedNameSpecifierLoc(V->get())) 2188 return true; 2189 continue; 2190 } 2191 2192 case VisitorJob::DeclarationNameInfoVisitKind: { 2193 if (VisitDeclarationNameInfo(cast<DeclarationNameInfoVisit>(&LI) 2194 ->get())) 2195 return true; 2196 continue; 2197 } 2198 case VisitorJob::MemberRefVisitKind: { 2199 MemberRefVisit *V = cast<MemberRefVisit>(&LI); 2200 if (Visit(MakeCursorMemberRef(V->get(), V->getLoc(), TU))) 2201 return true; 2202 continue; 2203 } 2204 case VisitorJob::StmtVisitKind: { 2205 Stmt *S = cast<StmtVisit>(&LI)->get(); 2206 if (!S) 2207 continue; 2208 2209 // Update the current cursor. 2210 CXCursor Cursor = MakeCXCursor(S, StmtParent, TU); 2211 if (!IsInRegionOfInterest(Cursor)) 2212 continue; 2213 switch (Visitor(Cursor, Parent, ClientData)) { 2214 case CXChildVisit_Break: return true; 2215 case CXChildVisit_Continue: break; 2216 case CXChildVisit_Recurse: 2217 EnqueueWorkList(WL, S); 2218 break; 2219 } 2220 continue; 2221 } 2222 case VisitorJob::MemberExprPartsKind: { 2223 // Handle the other pieces in the MemberExpr besides the base. 2224 MemberExpr *M = cast<MemberExprParts>(&LI)->get(); 2225 2226 // Visit the nested-name-specifier 2227 if (NestedNameSpecifierLoc QualifierLoc = M->getQualifierLoc()) 2228 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2229 return true; 2230 2231 // Visit the declaration name. 2232 if (VisitDeclarationNameInfo(M->getMemberNameInfo())) 2233 return true; 2234 2235 // Visit the explicitly-specified template arguments, if any. 2236 if (M->hasExplicitTemplateArgs()) { 2237 for (const TemplateArgumentLoc *Arg = M->getTemplateArgs(), 2238 *ArgEnd = Arg + M->getNumTemplateArgs(); 2239 Arg != ArgEnd; ++Arg) { 2240 if (VisitTemplateArgumentLoc(*Arg)) 2241 return true; 2242 } 2243 } 2244 continue; 2245 } 2246 case VisitorJob::DeclRefExprPartsKind: { 2247 DeclRefExpr *DR = cast<DeclRefExprParts>(&LI)->get(); 2248 // Visit nested-name-specifier, if present. 2249 if (NestedNameSpecifierLoc QualifierLoc = DR->getQualifierLoc()) 2250 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2251 return true; 2252 // Visit declaration name. 2253 if (VisitDeclarationNameInfo(DR->getNameInfo())) 2254 return true; 2255 continue; 2256 } 2257 case VisitorJob::OverloadExprPartsKind: { 2258 OverloadExpr *O = cast<OverloadExprParts>(&LI)->get(); 2259 // Visit the nested-name-specifier. 2260 if (NestedNameSpecifierLoc QualifierLoc = O->getQualifierLoc()) 2261 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2262 return true; 2263 // Visit the declaration name. 2264 if (VisitDeclarationNameInfo(O->getNameInfo())) 2265 return true; 2266 // Visit the overloaded declaration reference. 2267 if (Visit(MakeCursorOverloadedDeclRef(O, TU))) 2268 return true; 2269 continue; 2270 } 2271 case VisitorJob::SizeOfPackExprPartsKind: { 2272 SizeOfPackExpr *E = cast<SizeOfPackExprParts>(&LI)->get(); 2273 NamedDecl *Pack = E->getPack(); 2274 if (isa<TemplateTypeParmDecl>(Pack)) { 2275 if (Visit(MakeCursorTypeRef(cast<TemplateTypeParmDecl>(Pack), 2276 E->getPackLoc(), TU))) 2277 return true; 2278 2279 continue; 2280 } 2281 2282 if (isa<TemplateTemplateParmDecl>(Pack)) { 2283 if (Visit(MakeCursorTemplateRef(cast<TemplateTemplateParmDecl>(Pack), 2284 E->getPackLoc(), TU))) 2285 return true; 2286 2287 continue; 2288 } 2289 2290 // Non-type template parameter packs and function parameter packs are 2291 // treated like DeclRefExpr cursors. 2292 continue; 2293 } 2294 } 2295 } 2296 return false; 2297} 2298 2299bool CursorVisitor::Visit(Stmt *S) { 2300 VisitorWorkList *WL = 0; 2301 if (!WorkListFreeList.empty()) { 2302 WL = WorkListFreeList.back(); 2303 WL->clear(); 2304 WorkListFreeList.pop_back(); 2305 } 2306 else { 2307 WL = new VisitorWorkList(); 2308 WorkListCache.push_back(WL); 2309 } 2310 EnqueueWorkList(*WL, S); 2311 bool result = RunVisitorWorkList(*WL); 2312 WorkListFreeList.push_back(WL); 2313 return result; 2314} 2315 2316//===----------------------------------------------------------------------===// 2317// Misc. API hooks. 2318//===----------------------------------------------------------------------===// 2319 2320static llvm::sys::Mutex EnableMultithreadingMutex; 2321static bool EnabledMultithreading; 2322 2323extern "C" { 2324CXIndex clang_createIndex(int excludeDeclarationsFromPCH, 2325 int displayDiagnostics) { 2326 // Disable pretty stack trace functionality, which will otherwise be a very 2327 // poor citizen of the world and set up all sorts of signal handlers. 2328 llvm::DisablePrettyStackTrace = true; 2329 2330 // We use crash recovery to make some of our APIs more reliable, implicitly 2331 // enable it. 2332 llvm::CrashRecoveryContext::Enable(); 2333 2334 // Enable support for multithreading in LLVM. 2335 { 2336 llvm::sys::ScopedLock L(EnableMultithreadingMutex); 2337 if (!EnabledMultithreading) { 2338 llvm::llvm_start_multithreaded(); 2339 EnabledMultithreading = true; 2340 } 2341 } 2342 2343 CIndexer *CIdxr = new CIndexer(); 2344 if (excludeDeclarationsFromPCH) 2345 CIdxr->setOnlyLocalDecls(); 2346 if (displayDiagnostics) 2347 CIdxr->setDisplayDiagnostics(); 2348 return CIdxr; 2349} 2350 2351void clang_disposeIndex(CXIndex CIdx) { 2352 if (CIdx) 2353 delete static_cast<CIndexer *>(CIdx); 2354} 2355 2356void clang_toggleCrashRecovery(unsigned isEnabled) { 2357 if (isEnabled) 2358 llvm::CrashRecoveryContext::Enable(); 2359 else 2360 llvm::CrashRecoveryContext::Disable(); 2361} 2362 2363CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx, 2364 const char *ast_filename) { 2365 if (!CIdx) 2366 return 0; 2367 2368 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx); 2369 FileSystemOptions FileSystemOpts; 2370 FileSystemOpts.WorkingDir = CXXIdx->getWorkingDirectory(); 2371 2372 llvm::IntrusiveRefCntPtr<Diagnostic> Diags; 2373 ASTUnit *TU = ASTUnit::LoadFromASTFile(ast_filename, Diags, FileSystemOpts, 2374 CXXIdx->getOnlyLocalDecls(), 2375 0, 0, true); 2376 return MakeCXTranslationUnit(TU); 2377} 2378 2379unsigned clang_defaultEditingTranslationUnitOptions() { 2380 return CXTranslationUnit_PrecompiledPreamble | 2381 CXTranslationUnit_CacheCompletionResults | 2382 CXTranslationUnit_CXXPrecompiledPreamble | 2383 CXTranslationUnit_CXXChainedPCH; 2384} 2385 2386CXTranslationUnit 2387clang_createTranslationUnitFromSourceFile(CXIndex CIdx, 2388 const char *source_filename, 2389 int num_command_line_args, 2390 const char * const *command_line_args, 2391 unsigned num_unsaved_files, 2392 struct CXUnsavedFile *unsaved_files) { 2393 unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord | 2394 CXTranslationUnit_NestedMacroInstantiations; 2395 return clang_parseTranslationUnit(CIdx, source_filename, 2396 command_line_args, num_command_line_args, 2397 unsaved_files, num_unsaved_files, 2398 Options); 2399} 2400 2401struct ParseTranslationUnitInfo { 2402 CXIndex CIdx; 2403 const char *source_filename; 2404 const char *const *command_line_args; 2405 int num_command_line_args; 2406 struct CXUnsavedFile *unsaved_files; 2407 unsigned num_unsaved_files; 2408 unsigned options; 2409 CXTranslationUnit result; 2410}; 2411static void clang_parseTranslationUnit_Impl(void *UserData) { 2412 ParseTranslationUnitInfo *PTUI = 2413 static_cast<ParseTranslationUnitInfo*>(UserData); 2414 CXIndex CIdx = PTUI->CIdx; 2415 const char *source_filename = PTUI->source_filename; 2416 const char * const *command_line_args = PTUI->command_line_args; 2417 int num_command_line_args = PTUI->num_command_line_args; 2418 struct CXUnsavedFile *unsaved_files = PTUI->unsaved_files; 2419 unsigned num_unsaved_files = PTUI->num_unsaved_files; 2420 unsigned options = PTUI->options; 2421 PTUI->result = 0; 2422 2423 if (!CIdx) 2424 return; 2425 2426 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx); 2427 2428 bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble; 2429 bool CompleteTranslationUnit 2430 = ((options & CXTranslationUnit_Incomplete) == 0); 2431 bool CacheCodeCompetionResults 2432 = options & CXTranslationUnit_CacheCompletionResults; 2433 bool CXXPrecompilePreamble 2434 = options & CXTranslationUnit_CXXPrecompiledPreamble; 2435 bool CXXChainedPCH 2436 = options & CXTranslationUnit_CXXChainedPCH; 2437 2438 // Configure the diagnostics. 2439 DiagnosticOptions DiagOpts; 2440 llvm::IntrusiveRefCntPtr<Diagnostic> 2441 Diags(CompilerInstance::createDiagnostics(DiagOpts, num_command_line_args, 2442 command_line_args)); 2443 2444 // Recover resources if we crash before exiting this function. 2445 llvm::CrashRecoveryContextCleanupRegistrar<Diagnostic, 2446 llvm::CrashRecoveryContextReleaseRefCleanup<Diagnostic> > 2447 DiagCleanup(Diags.getPtr()); 2448 2449 llvm::OwningPtr<std::vector<ASTUnit::RemappedFile> > 2450 RemappedFiles(new std::vector<ASTUnit::RemappedFile>()); 2451 2452 // Recover resources if we crash before exiting this function. 2453 llvm::CrashRecoveryContextCleanupRegistrar< 2454 std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get()); 2455 2456 for (unsigned I = 0; I != num_unsaved_files; ++I) { 2457 llvm::StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length); 2458 const llvm::MemoryBuffer *Buffer 2459 = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename); 2460 RemappedFiles->push_back(std::make_pair(unsaved_files[I].Filename, 2461 Buffer)); 2462 } 2463 2464 llvm::OwningPtr<std::vector<const char *> > 2465 Args(new std::vector<const char*>()); 2466 2467 // Recover resources if we crash before exiting this method. 2468 llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char*> > 2469 ArgsCleanup(Args.get()); 2470 2471 // Since the Clang C library is primarily used by batch tools dealing with 2472 // (often very broken) source code, where spell-checking can have a 2473 // significant negative impact on performance (particularly when 2474 // precompiled headers are involved), we disable it by default. 2475 // Only do this if we haven't found a spell-checking-related argument. 2476 bool FoundSpellCheckingArgument = false; 2477 for (int I = 0; I != num_command_line_args; ++I) { 2478 if (strcmp(command_line_args[I], "-fno-spell-checking") == 0 || 2479 strcmp(command_line_args[I], "-fspell-checking") == 0) { 2480 FoundSpellCheckingArgument = true; 2481 break; 2482 } 2483 } 2484 if (!FoundSpellCheckingArgument) 2485 Args->push_back("-fno-spell-checking"); 2486 2487 Args->insert(Args->end(), command_line_args, 2488 command_line_args + num_command_line_args); 2489 2490 // The 'source_filename' argument is optional. If the caller does not 2491 // specify it then it is assumed that the source file is specified 2492 // in the actual argument list. 2493 // Put the source file after command_line_args otherwise if '-x' flag is 2494 // present it will be unused. 2495 if (source_filename) 2496 Args->push_back(source_filename); 2497 2498 // Do we need the detailed preprocessing record? 2499 bool NestedMacroInstantiations = false; 2500 if (options & CXTranslationUnit_DetailedPreprocessingRecord) { 2501 Args->push_back("-Xclang"); 2502 Args->push_back("-detailed-preprocessing-record"); 2503 NestedMacroInstantiations 2504 = (options & CXTranslationUnit_NestedMacroInstantiations); 2505 } 2506 2507 unsigned NumErrors = Diags->getClient()->getNumErrors(); 2508 llvm::OwningPtr<ASTUnit> Unit( 2509 ASTUnit::LoadFromCommandLine(Args->size() ? &(*Args)[0] : 0 2510 /* vector::data() not portable */, 2511 Args->size() ? (&(*Args)[0] + Args->size()) :0, 2512 Diags, 2513 CXXIdx->getClangResourcesPath(), 2514 CXXIdx->getOnlyLocalDecls(), 2515 /*CaptureDiagnostics=*/true, 2516 RemappedFiles->size() ? &(*RemappedFiles)[0]:0, 2517 RemappedFiles->size(), 2518 /*RemappedFilesKeepOriginalName=*/true, 2519 PrecompilePreamble, 2520 CompleteTranslationUnit, 2521 CacheCodeCompetionResults, 2522 CXXPrecompilePreamble, 2523 CXXChainedPCH, 2524 NestedMacroInstantiations)); 2525 2526 if (NumErrors != Diags->getClient()->getNumErrors()) { 2527 // Make sure to check that 'Unit' is non-NULL. 2528 if (CXXIdx->getDisplayDiagnostics() && Unit.get()) { 2529 for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(), 2530 DEnd = Unit->stored_diag_end(); 2531 D != DEnd; ++D) { 2532 CXStoredDiagnostic Diag(*D, Unit->getASTContext().getLangOptions()); 2533 CXString Msg = clang_formatDiagnostic(&Diag, 2534 clang_defaultDiagnosticDisplayOptions()); 2535 fprintf(stderr, "%s\n", clang_getCString(Msg)); 2536 clang_disposeString(Msg); 2537 } 2538#ifdef LLVM_ON_WIN32 2539 // On Windows, force a flush, since there may be multiple copies of 2540 // stderr and stdout in the file system, all with different buffers 2541 // but writing to the same device. 2542 fflush(stderr); 2543#endif 2544 } 2545 } 2546 2547 PTUI->result = MakeCXTranslationUnit(Unit.take()); 2548} 2549CXTranslationUnit clang_parseTranslationUnit(CXIndex CIdx, 2550 const char *source_filename, 2551 const char * const *command_line_args, 2552 int num_command_line_args, 2553 struct CXUnsavedFile *unsaved_files, 2554 unsigned num_unsaved_files, 2555 unsigned options) { 2556 ParseTranslationUnitInfo PTUI = { CIdx, source_filename, command_line_args, 2557 num_command_line_args, unsaved_files, 2558 num_unsaved_files, options, 0 }; 2559 llvm::CrashRecoveryContext CRC; 2560 2561 if (!RunSafely(CRC, clang_parseTranslationUnit_Impl, &PTUI)) { 2562 fprintf(stderr, "libclang: crash detected during parsing: {\n"); 2563 fprintf(stderr, " 'source_filename' : '%s'\n", source_filename); 2564 fprintf(stderr, " 'command_line_args' : ["); 2565 for (int i = 0; i != num_command_line_args; ++i) { 2566 if (i) 2567 fprintf(stderr, ", "); 2568 fprintf(stderr, "'%s'", command_line_args[i]); 2569 } 2570 fprintf(stderr, "],\n"); 2571 fprintf(stderr, " 'unsaved_files' : ["); 2572 for (unsigned i = 0; i != num_unsaved_files; ++i) { 2573 if (i) 2574 fprintf(stderr, ", "); 2575 fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename, 2576 unsaved_files[i].Length); 2577 } 2578 fprintf(stderr, "],\n"); 2579 fprintf(stderr, " 'options' : %d,\n", options); 2580 fprintf(stderr, "}\n"); 2581 2582 return 0; 2583 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) { 2584 PrintLibclangResourceUsage(PTUI.result); 2585 } 2586 2587 return PTUI.result; 2588} 2589 2590unsigned clang_defaultSaveOptions(CXTranslationUnit TU) { 2591 return CXSaveTranslationUnit_None; 2592} 2593 2594int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName, 2595 unsigned options) { 2596 if (!TU) 2597 return 1; 2598 2599 int result = static_cast<ASTUnit *>(TU->TUData)->Save(FileName); 2600 if (getenv("LIBCLANG_RESOURCE_USAGE")) 2601 PrintLibclangResourceUsage(TU); 2602 return result; 2603} 2604 2605void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) { 2606 if (CTUnit) { 2607 // If the translation unit has been marked as unsafe to free, just discard 2608 // it. 2609 if (static_cast<ASTUnit *>(CTUnit->TUData)->isUnsafeToFree()) 2610 return; 2611 2612 delete static_cast<ASTUnit *>(CTUnit->TUData); 2613 disposeCXStringPool(CTUnit->StringPool); 2614 delete CTUnit; 2615 } 2616} 2617 2618unsigned clang_defaultReparseOptions(CXTranslationUnit TU) { 2619 return CXReparse_None; 2620} 2621 2622struct ReparseTranslationUnitInfo { 2623 CXTranslationUnit TU; 2624 unsigned num_unsaved_files; 2625 struct CXUnsavedFile *unsaved_files; 2626 unsigned options; 2627 int result; 2628}; 2629 2630static void clang_reparseTranslationUnit_Impl(void *UserData) { 2631 ReparseTranslationUnitInfo *RTUI = 2632 static_cast<ReparseTranslationUnitInfo*>(UserData); 2633 CXTranslationUnit TU = RTUI->TU; 2634 unsigned num_unsaved_files = RTUI->num_unsaved_files; 2635 struct CXUnsavedFile *unsaved_files = RTUI->unsaved_files; 2636 unsigned options = RTUI->options; 2637 (void) options; 2638 RTUI->result = 1; 2639 2640 if (!TU) 2641 return; 2642 2643 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 2644 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 2645 2646 llvm::OwningPtr<std::vector<ASTUnit::RemappedFile> > 2647 RemappedFiles(new std::vector<ASTUnit::RemappedFile>()); 2648 2649 // Recover resources if we crash before exiting this function. 2650 llvm::CrashRecoveryContextCleanupRegistrar< 2651 std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get()); 2652 2653 for (unsigned I = 0; I != num_unsaved_files; ++I) { 2654 llvm::StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length); 2655 const llvm::MemoryBuffer *Buffer 2656 = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename); 2657 RemappedFiles->push_back(std::make_pair(unsaved_files[I].Filename, 2658 Buffer)); 2659 } 2660 2661 if (!CXXUnit->Reparse(RemappedFiles->size() ? &(*RemappedFiles)[0] : 0, 2662 RemappedFiles->size())) 2663 RTUI->result = 0; 2664} 2665 2666int clang_reparseTranslationUnit(CXTranslationUnit TU, 2667 unsigned num_unsaved_files, 2668 struct CXUnsavedFile *unsaved_files, 2669 unsigned options) { 2670 ReparseTranslationUnitInfo RTUI = { TU, num_unsaved_files, unsaved_files, 2671 options, 0 }; 2672 llvm::CrashRecoveryContext CRC; 2673 2674 if (!RunSafely(CRC, clang_reparseTranslationUnit_Impl, &RTUI)) { 2675 fprintf(stderr, "libclang: crash detected during reparsing\n"); 2676 static_cast<ASTUnit *>(TU->TUData)->setUnsafeToFree(true); 2677 return 1; 2678 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) 2679 PrintLibclangResourceUsage(TU); 2680 2681 return RTUI.result; 2682} 2683 2684 2685CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) { 2686 if (!CTUnit) 2687 return createCXString(""); 2688 2689 ASTUnit *CXXUnit = static_cast<ASTUnit *>(CTUnit->TUData); 2690 return createCXString(CXXUnit->getOriginalSourceFileName(), true); 2691} 2692 2693CXCursor clang_getTranslationUnitCursor(CXTranslationUnit TU) { 2694 CXCursor Result = { CXCursor_TranslationUnit, { 0, 0, TU } }; 2695 return Result; 2696} 2697 2698} // end: extern "C" 2699 2700//===----------------------------------------------------------------------===// 2701// CXSourceLocation and CXSourceRange Operations. 2702//===----------------------------------------------------------------------===// 2703 2704extern "C" { 2705CXSourceLocation clang_getNullLocation() { 2706 CXSourceLocation Result = { { 0, 0 }, 0 }; 2707 return Result; 2708} 2709 2710unsigned clang_equalLocations(CXSourceLocation loc1, CXSourceLocation loc2) { 2711 return (loc1.ptr_data[0] == loc2.ptr_data[0] && 2712 loc1.ptr_data[1] == loc2.ptr_data[1] && 2713 loc1.int_data == loc2.int_data); 2714} 2715 2716CXSourceLocation clang_getLocation(CXTranslationUnit tu, 2717 CXFile file, 2718 unsigned line, 2719 unsigned column) { 2720 if (!tu || !file) 2721 return clang_getNullLocation(); 2722 2723 bool Logging = ::getenv("LIBCLANG_LOGGING"); 2724 ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu->TUData); 2725 const FileEntry *File = static_cast<const FileEntry *>(file); 2726 SourceLocation SLoc 2727 = CXXUnit->getSourceManager().getLocation(File, line, column); 2728 if (SLoc.isInvalid()) { 2729 if (Logging) 2730 llvm::errs() << "clang_getLocation(\"" << File->getName() 2731 << "\", " << line << ", " << column << ") = invalid\n"; 2732 return clang_getNullLocation(); 2733 } 2734 2735 if (Logging) 2736 llvm::errs() << "clang_getLocation(\"" << File->getName() 2737 << "\", " << line << ", " << column << ") = " 2738 << SLoc.getRawEncoding() << "\n"; 2739 2740 return cxloc::translateSourceLocation(CXXUnit->getASTContext(), SLoc); 2741} 2742 2743CXSourceLocation clang_getLocationForOffset(CXTranslationUnit tu, 2744 CXFile file, 2745 unsigned offset) { 2746 if (!tu || !file) 2747 return clang_getNullLocation(); 2748 2749 ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu->TUData); 2750 SourceLocation Start 2751 = CXXUnit->getSourceManager().getLocation( 2752 static_cast<const FileEntry *>(file), 2753 1, 1); 2754 if (Start.isInvalid()) return clang_getNullLocation(); 2755 2756 SourceLocation SLoc = Start.getFileLocWithOffset(offset); 2757 2758 if (SLoc.isInvalid()) return clang_getNullLocation(); 2759 2760 return cxloc::translateSourceLocation(CXXUnit->getASTContext(), SLoc); 2761} 2762 2763CXSourceRange clang_getNullRange() { 2764 CXSourceRange Result = { { 0, 0 }, 0, 0 }; 2765 return Result; 2766} 2767 2768CXSourceRange clang_getRange(CXSourceLocation begin, CXSourceLocation end) { 2769 if (begin.ptr_data[0] != end.ptr_data[0] || 2770 begin.ptr_data[1] != end.ptr_data[1]) 2771 return clang_getNullRange(); 2772 2773 CXSourceRange Result = { { begin.ptr_data[0], begin.ptr_data[1] }, 2774 begin.int_data, end.int_data }; 2775 return Result; 2776} 2777} // end: extern "C" 2778 2779static void createNullLocation(CXFile *file, unsigned *line, 2780 unsigned *column, unsigned *offset) { 2781 if (file) 2782 *file = 0; 2783 if (line) 2784 *line = 0; 2785 if (column) 2786 *column = 0; 2787 if (offset) 2788 *offset = 0; 2789 return; 2790} 2791 2792extern "C" { 2793void clang_getInstantiationLocation(CXSourceLocation location, 2794 CXFile *file, 2795 unsigned *line, 2796 unsigned *column, 2797 unsigned *offset) { 2798 SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data); 2799 2800 if (!location.ptr_data[0] || Loc.isInvalid()) { 2801 createNullLocation(file, line, column, offset); 2802 return; 2803 } 2804 2805 const SourceManager &SM = 2806 *static_cast<const SourceManager*>(location.ptr_data[0]); 2807 SourceLocation InstLoc = SM.getInstantiationLoc(Loc); 2808 2809 // Check that the FileID is invalid on the instantiation location. 2810 // This can manifest in invalid code. 2811 FileID fileID = SM.getFileID(InstLoc); 2812 bool Invalid = false; 2813 const SrcMgr::SLocEntry &sloc = SM.getSLocEntry(fileID, &Invalid); 2814 if (!sloc.isFile() || Invalid) { 2815 createNullLocation(file, line, column, offset); 2816 return; 2817 } 2818 2819 if (file) 2820 *file = (void *)SM.getFileEntryForSLocEntry(sloc); 2821 if (line) 2822 *line = SM.getInstantiationLineNumber(InstLoc); 2823 if (column) 2824 *column = SM.getInstantiationColumnNumber(InstLoc); 2825 if (offset) 2826 *offset = SM.getDecomposedLoc(InstLoc).second; 2827} 2828 2829void clang_getSpellingLocation(CXSourceLocation location, 2830 CXFile *file, 2831 unsigned *line, 2832 unsigned *column, 2833 unsigned *offset) { 2834 SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data); 2835 2836 if (!location.ptr_data[0] || Loc.isInvalid()) 2837 return createNullLocation(file, line, column, offset); 2838 2839 const SourceManager &SM = 2840 *static_cast<const SourceManager*>(location.ptr_data[0]); 2841 SourceLocation SpellLoc = Loc; 2842 if (SpellLoc.isMacroID()) { 2843 SourceLocation SimpleSpellingLoc = SM.getImmediateSpellingLoc(SpellLoc); 2844 if (SimpleSpellingLoc.isFileID() && 2845 SM.getFileEntryForID(SM.getDecomposedLoc(SimpleSpellingLoc).first)) 2846 SpellLoc = SimpleSpellingLoc; 2847 else 2848 SpellLoc = SM.getInstantiationLoc(SpellLoc); 2849 } 2850 2851 std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(SpellLoc); 2852 FileID FID = LocInfo.first; 2853 unsigned FileOffset = LocInfo.second; 2854 2855 if (FID.isInvalid()) 2856 return createNullLocation(file, line, column, offset); 2857 2858 if (file) 2859 *file = (void *)SM.getFileEntryForID(FID); 2860 if (line) 2861 *line = SM.getLineNumber(FID, FileOffset); 2862 if (column) 2863 *column = SM.getColumnNumber(FID, FileOffset); 2864 if (offset) 2865 *offset = FileOffset; 2866} 2867 2868CXSourceLocation clang_getRangeStart(CXSourceRange range) { 2869 CXSourceLocation Result = { { range.ptr_data[0], range.ptr_data[1] }, 2870 range.begin_int_data }; 2871 return Result; 2872} 2873 2874CXSourceLocation clang_getRangeEnd(CXSourceRange range) { 2875 CXSourceLocation Result = { { range.ptr_data[0], range.ptr_data[1] }, 2876 range.end_int_data }; 2877 return Result; 2878} 2879 2880} // end: extern "C" 2881 2882//===----------------------------------------------------------------------===// 2883// CXFile Operations. 2884//===----------------------------------------------------------------------===// 2885 2886extern "C" { 2887CXString clang_getFileName(CXFile SFile) { 2888 if (!SFile) 2889 return createCXString((const char*)NULL); 2890 2891 FileEntry *FEnt = static_cast<FileEntry *>(SFile); 2892 return createCXString(FEnt->getName()); 2893} 2894 2895time_t clang_getFileTime(CXFile SFile) { 2896 if (!SFile) 2897 return 0; 2898 2899 FileEntry *FEnt = static_cast<FileEntry *>(SFile); 2900 return FEnt->getModificationTime(); 2901} 2902 2903CXFile clang_getFile(CXTranslationUnit tu, const char *file_name) { 2904 if (!tu) 2905 return 0; 2906 2907 ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu->TUData); 2908 2909 FileManager &FMgr = CXXUnit->getFileManager(); 2910 return const_cast<FileEntry *>(FMgr.getFile(file_name)); 2911} 2912 2913unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit tu, CXFile file) { 2914 if (!tu || !file) 2915 return 0; 2916 2917 ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu->TUData); 2918 FileEntry *FEnt = static_cast<FileEntry *>(file); 2919 return CXXUnit->getPreprocessor().getHeaderSearchInfo() 2920 .isFileMultipleIncludeGuarded(FEnt); 2921} 2922 2923} // end: extern "C" 2924 2925//===----------------------------------------------------------------------===// 2926// CXCursor Operations. 2927//===----------------------------------------------------------------------===// 2928 2929static Decl *getDeclFromExpr(Stmt *E) { 2930 if (CastExpr *CE = dyn_cast<CastExpr>(E)) 2931 return getDeclFromExpr(CE->getSubExpr()); 2932 2933 if (DeclRefExpr *RefExpr = dyn_cast<DeclRefExpr>(E)) 2934 return RefExpr->getDecl(); 2935 if (BlockDeclRefExpr *RefExpr = dyn_cast<BlockDeclRefExpr>(E)) 2936 return RefExpr->getDecl(); 2937 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) 2938 return ME->getMemberDecl(); 2939 if (ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(E)) 2940 return RE->getDecl(); 2941 if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(E)) 2942 return PRE->isExplicitProperty() ? PRE->getExplicitProperty() : 0; 2943 2944 if (CallExpr *CE = dyn_cast<CallExpr>(E)) 2945 return getDeclFromExpr(CE->getCallee()); 2946 if (CXXConstructExpr *CE = llvm::dyn_cast<CXXConstructExpr>(E)) 2947 if (!CE->isElidable()) 2948 return CE->getConstructor(); 2949 if (ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E)) 2950 return OME->getMethodDecl(); 2951 2952 if (ObjCProtocolExpr *PE = dyn_cast<ObjCProtocolExpr>(E)) 2953 return PE->getProtocol(); 2954 if (SubstNonTypeTemplateParmPackExpr *NTTP 2955 = dyn_cast<SubstNonTypeTemplateParmPackExpr>(E)) 2956 return NTTP->getParameterPack(); 2957 if (SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E)) 2958 if (isa<NonTypeTemplateParmDecl>(SizeOfPack->getPack()) || 2959 isa<ParmVarDecl>(SizeOfPack->getPack())) 2960 return SizeOfPack->getPack(); 2961 2962 return 0; 2963} 2964 2965static SourceLocation getLocationFromExpr(Expr *E) { 2966 if (ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E)) 2967 return /*FIXME:*/Msg->getLeftLoc(); 2968 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 2969 return DRE->getLocation(); 2970 if (BlockDeclRefExpr *RefExpr = dyn_cast<BlockDeclRefExpr>(E)) 2971 return RefExpr->getLocation(); 2972 if (MemberExpr *Member = dyn_cast<MemberExpr>(E)) 2973 return Member->getMemberLoc(); 2974 if (ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E)) 2975 return Ivar->getLocation(); 2976 if (SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E)) 2977 return SizeOfPack->getPackLoc(); 2978 2979 return E->getLocStart(); 2980} 2981 2982extern "C" { 2983 2984unsigned clang_visitChildren(CXCursor parent, 2985 CXCursorVisitor visitor, 2986 CXClientData client_data) { 2987 CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data, 2988 getCursorASTUnit(parent)->getMaxPCHLevel(), 2989 false); 2990 return CursorVis.VisitChildren(parent); 2991} 2992 2993#ifndef __has_feature 2994#define __has_feature(x) 0 2995#endif 2996#if __has_feature(blocks) 2997typedef enum CXChildVisitResult 2998 (^CXCursorVisitorBlock)(CXCursor cursor, CXCursor parent); 2999 3000static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent, 3001 CXClientData client_data) { 3002 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data; 3003 return block(cursor, parent); 3004} 3005#else 3006// If we are compiled with a compiler that doesn't have native blocks support, 3007// define and call the block manually, so the 3008typedef struct _CXChildVisitResult 3009{ 3010 void *isa; 3011 int flags; 3012 int reserved; 3013 enum CXChildVisitResult(*invoke)(struct _CXChildVisitResult*, CXCursor, 3014 CXCursor); 3015} *CXCursorVisitorBlock; 3016 3017static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent, 3018 CXClientData client_data) { 3019 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data; 3020 return block->invoke(block, cursor, parent); 3021} 3022#endif 3023 3024 3025unsigned clang_visitChildrenWithBlock(CXCursor parent, 3026 CXCursorVisitorBlock block) { 3027 return clang_visitChildren(parent, visitWithBlock, block); 3028} 3029 3030static CXString getDeclSpelling(Decl *D) { 3031 NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D); 3032 if (!ND) { 3033 if (ObjCPropertyImplDecl *PropImpl =llvm::dyn_cast<ObjCPropertyImplDecl>(D)) 3034 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) 3035 return createCXString(Property->getIdentifier()->getName()); 3036 3037 return createCXString(""); 3038 } 3039 3040 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND)) 3041 return createCXString(OMD->getSelector().getAsString()); 3042 3043 if (ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND)) 3044 // No, this isn't the same as the code below. getIdentifier() is non-virtual 3045 // and returns different names. NamedDecl returns the class name and 3046 // ObjCCategoryImplDecl returns the category name. 3047 return createCXString(CIMP->getIdentifier()->getNameStart()); 3048 3049 if (isa<UsingDirectiveDecl>(D)) 3050 return createCXString(""); 3051 3052 llvm::SmallString<1024> S; 3053 llvm::raw_svector_ostream os(S); 3054 ND->printName(os); 3055 3056 return createCXString(os.str()); 3057} 3058 3059CXString clang_getCursorSpelling(CXCursor C) { 3060 if (clang_isTranslationUnit(C.kind)) 3061 return clang_getTranslationUnitSpelling( 3062 static_cast<CXTranslationUnit>(C.data[2])); 3063 3064 if (clang_isReference(C.kind)) { 3065 switch (C.kind) { 3066 case CXCursor_ObjCSuperClassRef: { 3067 ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first; 3068 return createCXString(Super->getIdentifier()->getNameStart()); 3069 } 3070 case CXCursor_ObjCClassRef: { 3071 ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first; 3072 return createCXString(Class->getIdentifier()->getNameStart()); 3073 } 3074 case CXCursor_ObjCProtocolRef: { 3075 ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first; 3076 assert(OID && "getCursorSpelling(): Missing protocol decl"); 3077 return createCXString(OID->getIdentifier()->getNameStart()); 3078 } 3079 case CXCursor_CXXBaseSpecifier: { 3080 CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C); 3081 return createCXString(B->getType().getAsString()); 3082 } 3083 case CXCursor_TypeRef: { 3084 TypeDecl *Type = getCursorTypeRef(C).first; 3085 assert(Type && "Missing type decl"); 3086 3087 return createCXString(getCursorContext(C).getTypeDeclType(Type). 3088 getAsString()); 3089 } 3090 case CXCursor_TemplateRef: { 3091 TemplateDecl *Template = getCursorTemplateRef(C).first; 3092 assert(Template && "Missing template decl"); 3093 3094 return createCXString(Template->getNameAsString()); 3095 } 3096 3097 case CXCursor_NamespaceRef: { 3098 NamedDecl *NS = getCursorNamespaceRef(C).first; 3099 assert(NS && "Missing namespace decl"); 3100 3101 return createCXString(NS->getNameAsString()); 3102 } 3103 3104 case CXCursor_MemberRef: { 3105 FieldDecl *Field = getCursorMemberRef(C).first; 3106 assert(Field && "Missing member decl"); 3107 3108 return createCXString(Field->getNameAsString()); 3109 } 3110 3111 case CXCursor_LabelRef: { 3112 LabelStmt *Label = getCursorLabelRef(C).first; 3113 assert(Label && "Missing label"); 3114 3115 return createCXString(Label->getName()); 3116 } 3117 3118 case CXCursor_OverloadedDeclRef: { 3119 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; 3120 if (Decl *D = Storage.dyn_cast<Decl *>()) { 3121 if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) 3122 return createCXString(ND->getNameAsString()); 3123 return createCXString(""); 3124 } 3125 if (OverloadExpr *E = Storage.dyn_cast<OverloadExpr *>()) 3126 return createCXString(E->getName().getAsString()); 3127 OverloadedTemplateStorage *Ovl 3128 = Storage.get<OverloadedTemplateStorage*>(); 3129 if (Ovl->size() == 0) 3130 return createCXString(""); 3131 return createCXString((*Ovl->begin())->getNameAsString()); 3132 } 3133 3134 default: 3135 return createCXString("<not implemented>"); 3136 } 3137 } 3138 3139 if (clang_isExpression(C.kind)) { 3140 Decl *D = getDeclFromExpr(getCursorExpr(C)); 3141 if (D) 3142 return getDeclSpelling(D); 3143 return createCXString(""); 3144 } 3145 3146 if (clang_isStatement(C.kind)) { 3147 Stmt *S = getCursorStmt(C); 3148 if (LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) 3149 return createCXString(Label->getName()); 3150 3151 return createCXString(""); 3152 } 3153 3154 if (C.kind == CXCursor_MacroInstantiation) 3155 return createCXString(getCursorMacroInstantiation(C)->getName() 3156 ->getNameStart()); 3157 3158 if (C.kind == CXCursor_MacroDefinition) 3159 return createCXString(getCursorMacroDefinition(C)->getName() 3160 ->getNameStart()); 3161 3162 if (C.kind == CXCursor_InclusionDirective) 3163 return createCXString(getCursorInclusionDirective(C)->getFileName()); 3164 3165 if (clang_isDeclaration(C.kind)) 3166 return getDeclSpelling(getCursorDecl(C)); 3167 3168 return createCXString(""); 3169} 3170 3171CXString clang_getCursorDisplayName(CXCursor C) { 3172 if (!clang_isDeclaration(C.kind)) 3173 return clang_getCursorSpelling(C); 3174 3175 Decl *D = getCursorDecl(C); 3176 if (!D) 3177 return createCXString(""); 3178 3179 PrintingPolicy &Policy = getCursorContext(C).PrintingPolicy; 3180 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) 3181 D = FunTmpl->getTemplatedDecl(); 3182 3183 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 3184 llvm::SmallString<64> Str; 3185 llvm::raw_svector_ostream OS(Str); 3186 OS << Function->getNameAsString(); 3187 if (Function->getPrimaryTemplate()) 3188 OS << "<>"; 3189 OS << "("; 3190 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) { 3191 if (I) 3192 OS << ", "; 3193 OS << Function->getParamDecl(I)->getType().getAsString(Policy); 3194 } 3195 3196 if (Function->isVariadic()) { 3197 if (Function->getNumParams()) 3198 OS << ", "; 3199 OS << "..."; 3200 } 3201 OS << ")"; 3202 return createCXString(OS.str()); 3203 } 3204 3205 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) { 3206 llvm::SmallString<64> Str; 3207 llvm::raw_svector_ostream OS(Str); 3208 OS << ClassTemplate->getNameAsString(); 3209 OS << "<"; 3210 TemplateParameterList *Params = ClassTemplate->getTemplateParameters(); 3211 for (unsigned I = 0, N = Params->size(); I != N; ++I) { 3212 if (I) 3213 OS << ", "; 3214 3215 NamedDecl *Param = Params->getParam(I); 3216 if (Param->getIdentifier()) { 3217 OS << Param->getIdentifier()->getName(); 3218 continue; 3219 } 3220 3221 // There is no parameter name, which makes this tricky. Try to come up 3222 // with something useful that isn't too long. 3223 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) 3224 OS << (TTP->wasDeclaredWithTypename()? "typename" : "class"); 3225 else if (NonTypeTemplateParmDecl *NTTP 3226 = dyn_cast<NonTypeTemplateParmDecl>(Param)) 3227 OS << NTTP->getType().getAsString(Policy); 3228 else 3229 OS << "template<...> class"; 3230 } 3231 3232 OS << ">"; 3233 return createCXString(OS.str()); 3234 } 3235 3236 if (ClassTemplateSpecializationDecl *ClassSpec 3237 = dyn_cast<ClassTemplateSpecializationDecl>(D)) { 3238 // If the type was explicitly written, use that. 3239 if (TypeSourceInfo *TSInfo = ClassSpec->getTypeAsWritten()) 3240 return createCXString(TSInfo->getType().getAsString(Policy)); 3241 3242 llvm::SmallString<64> Str; 3243 llvm::raw_svector_ostream OS(Str); 3244 OS << ClassSpec->getNameAsString(); 3245 OS << TemplateSpecializationType::PrintTemplateArgumentList( 3246 ClassSpec->getTemplateArgs().data(), 3247 ClassSpec->getTemplateArgs().size(), 3248 Policy); 3249 return createCXString(OS.str()); 3250 } 3251 3252 return clang_getCursorSpelling(C); 3253} 3254 3255CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) { 3256 switch (Kind) { 3257 case CXCursor_FunctionDecl: 3258 return createCXString("FunctionDecl"); 3259 case CXCursor_TypedefDecl: 3260 return createCXString("TypedefDecl"); 3261 case CXCursor_EnumDecl: 3262 return createCXString("EnumDecl"); 3263 case CXCursor_EnumConstantDecl: 3264 return createCXString("EnumConstantDecl"); 3265 case CXCursor_StructDecl: 3266 return createCXString("StructDecl"); 3267 case CXCursor_UnionDecl: 3268 return createCXString("UnionDecl"); 3269 case CXCursor_ClassDecl: 3270 return createCXString("ClassDecl"); 3271 case CXCursor_FieldDecl: 3272 return createCXString("FieldDecl"); 3273 case CXCursor_VarDecl: 3274 return createCXString("VarDecl"); 3275 case CXCursor_ParmDecl: 3276 return createCXString("ParmDecl"); 3277 case CXCursor_ObjCInterfaceDecl: 3278 return createCXString("ObjCInterfaceDecl"); 3279 case CXCursor_ObjCCategoryDecl: 3280 return createCXString("ObjCCategoryDecl"); 3281 case CXCursor_ObjCProtocolDecl: 3282 return createCXString("ObjCProtocolDecl"); 3283 case CXCursor_ObjCPropertyDecl: 3284 return createCXString("ObjCPropertyDecl"); 3285 case CXCursor_ObjCIvarDecl: 3286 return createCXString("ObjCIvarDecl"); 3287 case CXCursor_ObjCInstanceMethodDecl: 3288 return createCXString("ObjCInstanceMethodDecl"); 3289 case CXCursor_ObjCClassMethodDecl: 3290 return createCXString("ObjCClassMethodDecl"); 3291 case CXCursor_ObjCImplementationDecl: 3292 return createCXString("ObjCImplementationDecl"); 3293 case CXCursor_ObjCCategoryImplDecl: 3294 return createCXString("ObjCCategoryImplDecl"); 3295 case CXCursor_CXXMethod: 3296 return createCXString("CXXMethod"); 3297 case CXCursor_UnexposedDecl: 3298 return createCXString("UnexposedDecl"); 3299 case CXCursor_ObjCSuperClassRef: 3300 return createCXString("ObjCSuperClassRef"); 3301 case CXCursor_ObjCProtocolRef: 3302 return createCXString("ObjCProtocolRef"); 3303 case CXCursor_ObjCClassRef: 3304 return createCXString("ObjCClassRef"); 3305 case CXCursor_TypeRef: 3306 return createCXString("TypeRef"); 3307 case CXCursor_TemplateRef: 3308 return createCXString("TemplateRef"); 3309 case CXCursor_NamespaceRef: 3310 return createCXString("NamespaceRef"); 3311 case CXCursor_MemberRef: 3312 return createCXString("MemberRef"); 3313 case CXCursor_LabelRef: 3314 return createCXString("LabelRef"); 3315 case CXCursor_OverloadedDeclRef: 3316 return createCXString("OverloadedDeclRef"); 3317 case CXCursor_UnexposedExpr: 3318 return createCXString("UnexposedExpr"); 3319 case CXCursor_BlockExpr: 3320 return createCXString("BlockExpr"); 3321 case CXCursor_DeclRefExpr: 3322 return createCXString("DeclRefExpr"); 3323 case CXCursor_MemberRefExpr: 3324 return createCXString("MemberRefExpr"); 3325 case CXCursor_CallExpr: 3326 return createCXString("CallExpr"); 3327 case CXCursor_ObjCMessageExpr: 3328 return createCXString("ObjCMessageExpr"); 3329 case CXCursor_UnexposedStmt: 3330 return createCXString("UnexposedStmt"); 3331 case CXCursor_LabelStmt: 3332 return createCXString("LabelStmt"); 3333 case CXCursor_InvalidFile: 3334 return createCXString("InvalidFile"); 3335 case CXCursor_InvalidCode: 3336 return createCXString("InvalidCode"); 3337 case CXCursor_NoDeclFound: 3338 return createCXString("NoDeclFound"); 3339 case CXCursor_NotImplemented: 3340 return createCXString("NotImplemented"); 3341 case CXCursor_TranslationUnit: 3342 return createCXString("TranslationUnit"); 3343 case CXCursor_UnexposedAttr: 3344 return createCXString("UnexposedAttr"); 3345 case CXCursor_IBActionAttr: 3346 return createCXString("attribute(ibaction)"); 3347 case CXCursor_IBOutletAttr: 3348 return createCXString("attribute(iboutlet)"); 3349 case CXCursor_IBOutletCollectionAttr: 3350 return createCXString("attribute(iboutletcollection)"); 3351 case CXCursor_PreprocessingDirective: 3352 return createCXString("preprocessing directive"); 3353 case CXCursor_MacroDefinition: 3354 return createCXString("macro definition"); 3355 case CXCursor_MacroInstantiation: 3356 return createCXString("macro instantiation"); 3357 case CXCursor_InclusionDirective: 3358 return createCXString("inclusion directive"); 3359 case CXCursor_Namespace: 3360 return createCXString("Namespace"); 3361 case CXCursor_LinkageSpec: 3362 return createCXString("LinkageSpec"); 3363 case CXCursor_CXXBaseSpecifier: 3364 return createCXString("C++ base class specifier"); 3365 case CXCursor_Constructor: 3366 return createCXString("CXXConstructor"); 3367 case CXCursor_Destructor: 3368 return createCXString("CXXDestructor"); 3369 case CXCursor_ConversionFunction: 3370 return createCXString("CXXConversion"); 3371 case CXCursor_TemplateTypeParameter: 3372 return createCXString("TemplateTypeParameter"); 3373 case CXCursor_NonTypeTemplateParameter: 3374 return createCXString("NonTypeTemplateParameter"); 3375 case CXCursor_TemplateTemplateParameter: 3376 return createCXString("TemplateTemplateParameter"); 3377 case CXCursor_FunctionTemplate: 3378 return createCXString("FunctionTemplate"); 3379 case CXCursor_ClassTemplate: 3380 return createCXString("ClassTemplate"); 3381 case CXCursor_ClassTemplatePartialSpecialization: 3382 return createCXString("ClassTemplatePartialSpecialization"); 3383 case CXCursor_NamespaceAlias: 3384 return createCXString("NamespaceAlias"); 3385 case CXCursor_UsingDirective: 3386 return createCXString("UsingDirective"); 3387 case CXCursor_UsingDeclaration: 3388 return createCXString("UsingDeclaration"); 3389 case CXCursor_TypeAliasDecl: 3390 return createCXString("TypeAliasDecl"); 3391 case CXCursor_ObjCSynthesizeDecl: 3392 return createCXString("ObjCSynthesizeDecl"); 3393 case CXCursor_ObjCDynamicDecl: 3394 return createCXString("ObjCDynamicDecl"); 3395 } 3396 3397 llvm_unreachable("Unhandled CXCursorKind"); 3398 return createCXString((const char*) 0); 3399} 3400 3401struct GetCursorData { 3402 SourceLocation TokenBeginLoc; 3403 CXCursor &BestCursor; 3404 3405 GetCursorData(SourceLocation tokenBegin, CXCursor &outputCursor) 3406 : TokenBeginLoc(tokenBegin), BestCursor(outputCursor) { } 3407}; 3408 3409enum CXChildVisitResult GetCursorVisitor(CXCursor cursor, 3410 CXCursor parent, 3411 CXClientData client_data) { 3412 GetCursorData *Data = static_cast<GetCursorData *>(client_data); 3413 CXCursor *BestCursor = &Data->BestCursor; 3414 3415 if (clang_isExpression(cursor.kind) && 3416 clang_isDeclaration(BestCursor->kind)) { 3417 Decl *D = getCursorDecl(*BestCursor); 3418 3419 // Avoid having the cursor of an expression replace the declaration cursor 3420 // when the expression source range overlaps the declaration range. 3421 // This can happen for C++ constructor expressions whose range generally 3422 // include the variable declaration, e.g.: 3423 // MyCXXClass foo; // Make sure pointing at 'foo' returns a VarDecl cursor. 3424 if (D->getLocation().isValid() && Data->TokenBeginLoc.isValid() && 3425 D->getLocation() == Data->TokenBeginLoc) 3426 return CXChildVisit_Break; 3427 } 3428 3429 // If our current best cursor is the construction of a temporary object, 3430 // don't replace that cursor with a type reference, because we want 3431 // clang_getCursor() to point at the constructor. 3432 if (clang_isExpression(BestCursor->kind) && 3433 isa<CXXTemporaryObjectExpr>(getCursorExpr(*BestCursor)) && 3434 cursor.kind == CXCursor_TypeRef) 3435 return CXChildVisit_Recurse; 3436 3437 // Don't override a preprocessing cursor with another preprocessing 3438 // cursor; we want the outermost preprocessing cursor. 3439 if (clang_isPreprocessing(cursor.kind) && 3440 clang_isPreprocessing(BestCursor->kind)) 3441 return CXChildVisit_Recurse; 3442 3443 *BestCursor = cursor; 3444 return CXChildVisit_Recurse; 3445} 3446 3447CXCursor clang_getCursor(CXTranslationUnit TU, CXSourceLocation Loc) { 3448 if (!TU) 3449 return clang_getNullCursor(); 3450 3451 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 3452 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 3453 3454 // Translate the given source location to make it point at the beginning of 3455 // the token under the cursor. 3456 SourceLocation SLoc = cxloc::translateSourceLocation(Loc); 3457 3458 // Guard against an invalid SourceLocation, or we may assert in one 3459 // of the following calls. 3460 if (SLoc.isInvalid()) 3461 return clang_getNullCursor(); 3462 3463 bool Logging = getenv("LIBCLANG_LOGGING"); 3464 SLoc = Lexer::GetBeginningOfToken(SLoc, CXXUnit->getSourceManager(), 3465 CXXUnit->getASTContext().getLangOptions()); 3466 3467 CXCursor Result = MakeCXCursorInvalid(CXCursor_NoDeclFound); 3468 if (SLoc.isValid()) { 3469 // FIXME: Would be great to have a "hint" cursor, then walk from that 3470 // hint cursor upward until we find a cursor whose source range encloses 3471 // the region of interest, rather than starting from the translation unit. 3472 GetCursorData ResultData(SLoc, Result); 3473 CXCursor Parent = clang_getTranslationUnitCursor(TU); 3474 CursorVisitor CursorVis(TU, GetCursorVisitor, &ResultData, 3475 Decl::MaxPCHLevel, true, SourceLocation(SLoc)); 3476 CursorVis.VisitChildren(Parent); 3477 } 3478 3479 if (Logging) { 3480 CXFile SearchFile; 3481 unsigned SearchLine, SearchColumn; 3482 CXFile ResultFile; 3483 unsigned ResultLine, ResultColumn; 3484 CXString SearchFileName, ResultFileName, KindSpelling, USR; 3485 const char *IsDef = clang_isCursorDefinition(Result)? " (Definition)" : ""; 3486 CXSourceLocation ResultLoc = clang_getCursorLocation(Result); 3487 3488 clang_getInstantiationLocation(Loc, &SearchFile, &SearchLine, &SearchColumn, 3489 0); 3490 clang_getInstantiationLocation(ResultLoc, &ResultFile, &ResultLine, 3491 &ResultColumn, 0); 3492 SearchFileName = clang_getFileName(SearchFile); 3493 ResultFileName = clang_getFileName(ResultFile); 3494 KindSpelling = clang_getCursorKindSpelling(Result.kind); 3495 USR = clang_getCursorUSR(Result); 3496 fprintf(stderr, "clang_getCursor(%s:%d:%d) = %s(%s:%d:%d):%s%s\n", 3497 clang_getCString(SearchFileName), SearchLine, SearchColumn, 3498 clang_getCString(KindSpelling), 3499 clang_getCString(ResultFileName), ResultLine, ResultColumn, 3500 clang_getCString(USR), IsDef); 3501 clang_disposeString(SearchFileName); 3502 clang_disposeString(ResultFileName); 3503 clang_disposeString(KindSpelling); 3504 clang_disposeString(USR); 3505 3506 CXCursor Definition = clang_getCursorDefinition(Result); 3507 if (!clang_equalCursors(Definition, clang_getNullCursor())) { 3508 CXSourceLocation DefinitionLoc = clang_getCursorLocation(Definition); 3509 CXString DefinitionKindSpelling 3510 = clang_getCursorKindSpelling(Definition.kind); 3511 CXFile DefinitionFile; 3512 unsigned DefinitionLine, DefinitionColumn; 3513 clang_getInstantiationLocation(DefinitionLoc, &DefinitionFile, 3514 &DefinitionLine, &DefinitionColumn, 0); 3515 CXString DefinitionFileName = clang_getFileName(DefinitionFile); 3516 fprintf(stderr, " -> %s(%s:%d:%d)\n", 3517 clang_getCString(DefinitionKindSpelling), 3518 clang_getCString(DefinitionFileName), 3519 DefinitionLine, DefinitionColumn); 3520 clang_disposeString(DefinitionFileName); 3521 clang_disposeString(DefinitionKindSpelling); 3522 } 3523 } 3524 3525 return Result; 3526} 3527 3528CXCursor clang_getNullCursor(void) { 3529 return MakeCXCursorInvalid(CXCursor_InvalidFile); 3530} 3531 3532unsigned clang_equalCursors(CXCursor X, CXCursor Y) { 3533 return X == Y; 3534} 3535 3536unsigned clang_hashCursor(CXCursor C) { 3537 unsigned Index = 0; 3538 if (clang_isExpression(C.kind) || clang_isStatement(C.kind)) 3539 Index = 1; 3540 3541 return llvm::DenseMapInfo<std::pair<unsigned, void*> >::getHashValue( 3542 std::make_pair(C.kind, C.data[Index])); 3543} 3544 3545unsigned clang_isInvalid(enum CXCursorKind K) { 3546 return K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid; 3547} 3548 3549unsigned clang_isDeclaration(enum CXCursorKind K) { 3550 return K >= CXCursor_FirstDecl && K <= CXCursor_LastDecl; 3551} 3552 3553unsigned clang_isReference(enum CXCursorKind K) { 3554 return K >= CXCursor_FirstRef && K <= CXCursor_LastRef; 3555} 3556 3557unsigned clang_isExpression(enum CXCursorKind K) { 3558 return K >= CXCursor_FirstExpr && K <= CXCursor_LastExpr; 3559} 3560 3561unsigned clang_isStatement(enum CXCursorKind K) { 3562 return K >= CXCursor_FirstStmt && K <= CXCursor_LastStmt; 3563} 3564 3565unsigned clang_isAttribute(enum CXCursorKind K) { 3566 return K >= CXCursor_FirstAttr && K <= CXCursor_LastAttr; 3567} 3568 3569unsigned clang_isTranslationUnit(enum CXCursorKind K) { 3570 return K == CXCursor_TranslationUnit; 3571} 3572 3573unsigned clang_isPreprocessing(enum CXCursorKind K) { 3574 return K >= CXCursor_FirstPreprocessing && K <= CXCursor_LastPreprocessing; 3575} 3576 3577unsigned clang_isUnexposed(enum CXCursorKind K) { 3578 switch (K) { 3579 case CXCursor_UnexposedDecl: 3580 case CXCursor_UnexposedExpr: 3581 case CXCursor_UnexposedStmt: 3582 case CXCursor_UnexposedAttr: 3583 return true; 3584 default: 3585 return false; 3586 } 3587} 3588 3589CXCursorKind clang_getCursorKind(CXCursor C) { 3590 return C.kind; 3591} 3592 3593CXSourceLocation clang_getCursorLocation(CXCursor C) { 3594 if (clang_isReference(C.kind)) { 3595 switch (C.kind) { 3596 case CXCursor_ObjCSuperClassRef: { 3597 std::pair<ObjCInterfaceDecl *, SourceLocation> P 3598 = getCursorObjCSuperClassRef(C); 3599 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3600 } 3601 3602 case CXCursor_ObjCProtocolRef: { 3603 std::pair<ObjCProtocolDecl *, SourceLocation> P 3604 = getCursorObjCProtocolRef(C); 3605 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3606 } 3607 3608 case CXCursor_ObjCClassRef: { 3609 std::pair<ObjCInterfaceDecl *, SourceLocation> P 3610 = getCursorObjCClassRef(C); 3611 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3612 } 3613 3614 case CXCursor_TypeRef: { 3615 std::pair<TypeDecl *, SourceLocation> P = getCursorTypeRef(C); 3616 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3617 } 3618 3619 case CXCursor_TemplateRef: { 3620 std::pair<TemplateDecl *, SourceLocation> P = getCursorTemplateRef(C); 3621 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3622 } 3623 3624 case CXCursor_NamespaceRef: { 3625 std::pair<NamedDecl *, SourceLocation> P = getCursorNamespaceRef(C); 3626 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3627 } 3628 3629 case CXCursor_MemberRef: { 3630 std::pair<FieldDecl *, SourceLocation> P = getCursorMemberRef(C); 3631 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3632 } 3633 3634 case CXCursor_CXXBaseSpecifier: { 3635 CXXBaseSpecifier *BaseSpec = getCursorCXXBaseSpecifier(C); 3636 if (!BaseSpec) 3637 return clang_getNullLocation(); 3638 3639 if (TypeSourceInfo *TSInfo = BaseSpec->getTypeSourceInfo()) 3640 return cxloc::translateSourceLocation(getCursorContext(C), 3641 TSInfo->getTypeLoc().getBeginLoc()); 3642 3643 return cxloc::translateSourceLocation(getCursorContext(C), 3644 BaseSpec->getSourceRange().getBegin()); 3645 } 3646 3647 case CXCursor_LabelRef: { 3648 std::pair<LabelStmt *, SourceLocation> P = getCursorLabelRef(C); 3649 return cxloc::translateSourceLocation(getCursorContext(C), P.second); 3650 } 3651 3652 case CXCursor_OverloadedDeclRef: 3653 return cxloc::translateSourceLocation(getCursorContext(C), 3654 getCursorOverloadedDeclRef(C).second); 3655 3656 default: 3657 // FIXME: Need a way to enumerate all non-reference cases. 3658 llvm_unreachable("Missed a reference kind"); 3659 } 3660 } 3661 3662 if (clang_isExpression(C.kind)) 3663 return cxloc::translateSourceLocation(getCursorContext(C), 3664 getLocationFromExpr(getCursorExpr(C))); 3665 3666 if (clang_isStatement(C.kind)) 3667 return cxloc::translateSourceLocation(getCursorContext(C), 3668 getCursorStmt(C)->getLocStart()); 3669 3670 if (C.kind == CXCursor_PreprocessingDirective) { 3671 SourceLocation L = cxcursor::getCursorPreprocessingDirective(C).getBegin(); 3672 return cxloc::translateSourceLocation(getCursorContext(C), L); 3673 } 3674 3675 if (C.kind == CXCursor_MacroInstantiation) { 3676 SourceLocation L 3677 = cxcursor::getCursorMacroInstantiation(C)->getSourceRange().getBegin(); 3678 return cxloc::translateSourceLocation(getCursorContext(C), L); 3679 } 3680 3681 if (C.kind == CXCursor_MacroDefinition) { 3682 SourceLocation L = cxcursor::getCursorMacroDefinition(C)->getLocation(); 3683 return cxloc::translateSourceLocation(getCursorContext(C), L); 3684 } 3685 3686 if (C.kind == CXCursor_InclusionDirective) { 3687 SourceLocation L 3688 = cxcursor::getCursorInclusionDirective(C)->getSourceRange().getBegin(); 3689 return cxloc::translateSourceLocation(getCursorContext(C), L); 3690 } 3691 3692 if (C.kind < CXCursor_FirstDecl || C.kind > CXCursor_LastDecl) 3693 return clang_getNullLocation(); 3694 3695 Decl *D = getCursorDecl(C); 3696 SourceLocation Loc = D->getLocation(); 3697 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D)) 3698 Loc = Class->getClassLoc(); 3699 // FIXME: Multiple variables declared in a single declaration 3700 // currently lack the information needed to correctly determine their 3701 // ranges when accounting for the type-specifier. We use context 3702 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 3703 // and if so, whether it is the first decl. 3704 if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 3705 if (!cxcursor::isFirstInDeclGroup(C)) 3706 Loc = VD->getLocation(); 3707 } 3708 3709 return cxloc::translateSourceLocation(getCursorContext(C), Loc); 3710} 3711 3712} // end extern "C" 3713 3714static SourceRange getRawCursorExtent(CXCursor C) { 3715 if (clang_isReference(C.kind)) { 3716 switch (C.kind) { 3717 case CXCursor_ObjCSuperClassRef: 3718 return getCursorObjCSuperClassRef(C).second; 3719 3720 case CXCursor_ObjCProtocolRef: 3721 return getCursorObjCProtocolRef(C).second; 3722 3723 case CXCursor_ObjCClassRef: 3724 return getCursorObjCClassRef(C).second; 3725 3726 case CXCursor_TypeRef: 3727 return getCursorTypeRef(C).second; 3728 3729 case CXCursor_TemplateRef: 3730 return getCursorTemplateRef(C).second; 3731 3732 case CXCursor_NamespaceRef: 3733 return getCursorNamespaceRef(C).second; 3734 3735 case CXCursor_MemberRef: 3736 return getCursorMemberRef(C).second; 3737 3738 case CXCursor_CXXBaseSpecifier: 3739 return getCursorCXXBaseSpecifier(C)->getSourceRange(); 3740 3741 case CXCursor_LabelRef: 3742 return getCursorLabelRef(C).second; 3743 3744 case CXCursor_OverloadedDeclRef: 3745 return getCursorOverloadedDeclRef(C).second; 3746 3747 default: 3748 // FIXME: Need a way to enumerate all non-reference cases. 3749 llvm_unreachable("Missed a reference kind"); 3750 } 3751 } 3752 3753 if (clang_isExpression(C.kind)) 3754 return getCursorExpr(C)->getSourceRange(); 3755 3756 if (clang_isStatement(C.kind)) 3757 return getCursorStmt(C)->getSourceRange(); 3758 3759 if (C.kind == CXCursor_PreprocessingDirective) 3760 return cxcursor::getCursorPreprocessingDirective(C); 3761 3762 if (C.kind == CXCursor_MacroInstantiation) 3763 return cxcursor::getCursorMacroInstantiation(C)->getSourceRange(); 3764 3765 if (C.kind == CXCursor_MacroDefinition) 3766 return cxcursor::getCursorMacroDefinition(C)->getSourceRange(); 3767 3768 if (C.kind == CXCursor_InclusionDirective) 3769 return cxcursor::getCursorInclusionDirective(C)->getSourceRange(); 3770 3771 if (C.kind >= CXCursor_FirstDecl && C.kind <= CXCursor_LastDecl) { 3772 Decl *D = cxcursor::getCursorDecl(C); 3773 SourceRange R = D->getSourceRange(); 3774 // FIXME: Multiple variables declared in a single declaration 3775 // currently lack the information needed to correctly determine their 3776 // ranges when accounting for the type-specifier. We use context 3777 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 3778 // and if so, whether it is the first decl. 3779 if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 3780 if (!cxcursor::isFirstInDeclGroup(C)) 3781 R.setBegin(VD->getLocation()); 3782 } 3783 return R; 3784 } 3785 return SourceRange(); 3786} 3787 3788/// \brief Retrieves the "raw" cursor extent, which is then extended to include 3789/// the decl-specifier-seq for declarations. 3790static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) { 3791 if (C.kind >= CXCursor_FirstDecl && C.kind <= CXCursor_LastDecl) { 3792 Decl *D = cxcursor::getCursorDecl(C); 3793 SourceRange R = D->getSourceRange(); 3794 3795 // Adjust the start of the location for declarations preceded by 3796 // declaration specifiers. 3797 SourceLocation StartLoc; 3798 if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) { 3799 if (TypeSourceInfo *TI = DD->getTypeSourceInfo()) 3800 StartLoc = TI->getTypeLoc().getSourceRange().getBegin(); 3801 } else if (TypedefDecl *Typedef = dyn_cast<TypedefDecl>(D)) { 3802 if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo()) 3803 StartLoc = TI->getTypeLoc().getSourceRange().getBegin(); 3804 } 3805 3806 if (StartLoc.isValid() && R.getBegin().isValid() && 3807 SrcMgr.isBeforeInTranslationUnit(StartLoc, R.getBegin())) 3808 R.setBegin(StartLoc); 3809 3810 // FIXME: Multiple variables declared in a single declaration 3811 // currently lack the information needed to correctly determine their 3812 // ranges when accounting for the type-specifier. We use context 3813 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 3814 // and if so, whether it is the first decl. 3815 if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 3816 if (!cxcursor::isFirstInDeclGroup(C)) 3817 R.setBegin(VD->getLocation()); 3818 } 3819 3820 return R; 3821 } 3822 3823 return getRawCursorExtent(C); 3824} 3825 3826extern "C" { 3827 3828CXSourceRange clang_getCursorExtent(CXCursor C) { 3829 SourceRange R = getRawCursorExtent(C); 3830 if (R.isInvalid()) 3831 return clang_getNullRange(); 3832 3833 return cxloc::translateSourceRange(getCursorContext(C), R); 3834} 3835 3836CXCursor clang_getCursorReferenced(CXCursor C) { 3837 if (clang_isInvalid(C.kind)) 3838 return clang_getNullCursor(); 3839 3840 CXTranslationUnit tu = getCursorTU(C); 3841 if (clang_isDeclaration(C.kind)) { 3842 Decl *D = getCursorDecl(C); 3843 if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) 3844 return MakeCursorOverloadedDeclRef(Using, D->getLocation(), tu); 3845 if (ObjCClassDecl *Classes = dyn_cast<ObjCClassDecl>(D)) 3846 return MakeCursorOverloadedDeclRef(Classes, D->getLocation(), tu); 3847 if (ObjCForwardProtocolDecl *Protocols 3848 = dyn_cast<ObjCForwardProtocolDecl>(D)) 3849 return MakeCursorOverloadedDeclRef(Protocols, D->getLocation(), tu); 3850 if (ObjCPropertyImplDecl *PropImpl =llvm::dyn_cast<ObjCPropertyImplDecl>(D)) 3851 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) 3852 return MakeCXCursor(Property, tu); 3853 3854 return C; 3855 } 3856 3857 if (clang_isExpression(C.kind)) { 3858 Expr *E = getCursorExpr(C); 3859 Decl *D = getDeclFromExpr(E); 3860 if (D) 3861 return MakeCXCursor(D, tu); 3862 3863 if (OverloadExpr *Ovl = dyn_cast_or_null<OverloadExpr>(E)) 3864 return MakeCursorOverloadedDeclRef(Ovl, tu); 3865 3866 return clang_getNullCursor(); 3867 } 3868 3869 if (clang_isStatement(C.kind)) { 3870 Stmt *S = getCursorStmt(C); 3871 if (GotoStmt *Goto = dyn_cast_or_null<GotoStmt>(S)) 3872 if (LabelDecl *label = Goto->getLabel()) 3873 if (LabelStmt *labelS = label->getStmt()) 3874 return MakeCXCursor(labelS, getCursorDecl(C), tu); 3875 3876 return clang_getNullCursor(); 3877 } 3878 3879 if (C.kind == CXCursor_MacroInstantiation) { 3880 if (MacroDefinition *Def = getCursorMacroInstantiation(C)->getDefinition()) 3881 return MakeMacroDefinitionCursor(Def, tu); 3882 } 3883 3884 if (!clang_isReference(C.kind)) 3885 return clang_getNullCursor(); 3886 3887 switch (C.kind) { 3888 case CXCursor_ObjCSuperClassRef: 3889 return MakeCXCursor(getCursorObjCSuperClassRef(C).first, tu); 3890 3891 case CXCursor_ObjCProtocolRef: { 3892 return MakeCXCursor(getCursorObjCProtocolRef(C).first, tu); 3893 3894 case CXCursor_ObjCClassRef: 3895 return MakeCXCursor(getCursorObjCClassRef(C).first, tu ); 3896 3897 case CXCursor_TypeRef: 3898 return MakeCXCursor(getCursorTypeRef(C).first, tu ); 3899 3900 case CXCursor_TemplateRef: 3901 return MakeCXCursor(getCursorTemplateRef(C).first, tu ); 3902 3903 case CXCursor_NamespaceRef: 3904 return MakeCXCursor(getCursorNamespaceRef(C).first, tu ); 3905 3906 case CXCursor_MemberRef: 3907 return MakeCXCursor(getCursorMemberRef(C).first, tu ); 3908 3909 case CXCursor_CXXBaseSpecifier: { 3910 CXXBaseSpecifier *B = cxcursor::getCursorCXXBaseSpecifier(C); 3911 return clang_getTypeDeclaration(cxtype::MakeCXType(B->getType(), 3912 tu )); 3913 } 3914 3915 case CXCursor_LabelRef: 3916 // FIXME: We end up faking the "parent" declaration here because we 3917 // don't want to make CXCursor larger. 3918 return MakeCXCursor(getCursorLabelRef(C).first, 3919 static_cast<ASTUnit*>(tu->TUData)->getASTContext() 3920 .getTranslationUnitDecl(), 3921 tu); 3922 3923 case CXCursor_OverloadedDeclRef: 3924 return C; 3925 3926 default: 3927 // We would prefer to enumerate all non-reference cursor kinds here. 3928 llvm_unreachable("Unhandled reference cursor kind"); 3929 break; 3930 } 3931 } 3932 3933 return clang_getNullCursor(); 3934} 3935 3936CXCursor clang_getCursorDefinition(CXCursor C) { 3937 if (clang_isInvalid(C.kind)) 3938 return clang_getNullCursor(); 3939 3940 CXTranslationUnit TU = getCursorTU(C); 3941 3942 bool WasReference = false; 3943 if (clang_isReference(C.kind) || clang_isExpression(C.kind)) { 3944 C = clang_getCursorReferenced(C); 3945 WasReference = true; 3946 } 3947 3948 if (C.kind == CXCursor_MacroInstantiation) 3949 return clang_getCursorReferenced(C); 3950 3951 if (!clang_isDeclaration(C.kind)) 3952 return clang_getNullCursor(); 3953 3954 Decl *D = getCursorDecl(C); 3955 if (!D) 3956 return clang_getNullCursor(); 3957 3958 switch (D->getKind()) { 3959 // Declaration kinds that don't really separate the notions of 3960 // declaration and definition. 3961 case Decl::Namespace: 3962 case Decl::Typedef: 3963 case Decl::TypeAlias: 3964 case Decl::TypeAliasTemplate: 3965 case Decl::TemplateTypeParm: 3966 case Decl::EnumConstant: 3967 case Decl::Field: 3968 case Decl::IndirectField: 3969 case Decl::ObjCIvar: 3970 case Decl::ObjCAtDefsField: 3971 case Decl::ImplicitParam: 3972 case Decl::ParmVar: 3973 case Decl::NonTypeTemplateParm: 3974 case Decl::TemplateTemplateParm: 3975 case Decl::ObjCCategoryImpl: 3976 case Decl::ObjCImplementation: 3977 case Decl::AccessSpec: 3978 case Decl::LinkageSpec: 3979 case Decl::ObjCPropertyImpl: 3980 case Decl::FileScopeAsm: 3981 case Decl::StaticAssert: 3982 case Decl::Block: 3983 case Decl::Label: // FIXME: Is this right?? 3984 return C; 3985 3986 // Declaration kinds that don't make any sense here, but are 3987 // nonetheless harmless. 3988 case Decl::TranslationUnit: 3989 break; 3990 3991 // Declaration kinds for which the definition is not resolvable. 3992 case Decl::UnresolvedUsingTypename: 3993 case Decl::UnresolvedUsingValue: 3994 break; 3995 3996 case Decl::UsingDirective: 3997 return MakeCXCursor(cast<UsingDirectiveDecl>(D)->getNominatedNamespace(), 3998 TU); 3999 4000 case Decl::NamespaceAlias: 4001 return MakeCXCursor(cast<NamespaceAliasDecl>(D)->getNamespace(), TU); 4002 4003 case Decl::Enum: 4004 case Decl::Record: 4005 case Decl::CXXRecord: 4006 case Decl::ClassTemplateSpecialization: 4007 case Decl::ClassTemplatePartialSpecialization: 4008 if (TagDecl *Def = cast<TagDecl>(D)->getDefinition()) 4009 return MakeCXCursor(Def, TU); 4010 return clang_getNullCursor(); 4011 4012 case Decl::Function: 4013 case Decl::CXXMethod: 4014 case Decl::CXXConstructor: 4015 case Decl::CXXDestructor: 4016 case Decl::CXXConversion: { 4017 const FunctionDecl *Def = 0; 4018 if (cast<FunctionDecl>(D)->getBody(Def)) 4019 return MakeCXCursor(const_cast<FunctionDecl *>(Def), TU); 4020 return clang_getNullCursor(); 4021 } 4022 4023 case Decl::Var: { 4024 // Ask the variable if it has a definition. 4025 if (VarDecl *Def = cast<VarDecl>(D)->getDefinition()) 4026 return MakeCXCursor(Def, TU); 4027 return clang_getNullCursor(); 4028 } 4029 4030 case Decl::FunctionTemplate: { 4031 const FunctionDecl *Def = 0; 4032 if (cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->getBody(Def)) 4033 return MakeCXCursor(Def->getDescribedFunctionTemplate(), TU); 4034 return clang_getNullCursor(); 4035 } 4036 4037 case Decl::ClassTemplate: { 4038 if (RecordDecl *Def = cast<ClassTemplateDecl>(D)->getTemplatedDecl() 4039 ->getDefinition()) 4040 return MakeCXCursor(cast<CXXRecordDecl>(Def)->getDescribedClassTemplate(), 4041 TU); 4042 return clang_getNullCursor(); 4043 } 4044 4045 case Decl::Using: 4046 return MakeCursorOverloadedDeclRef(cast<UsingDecl>(D), 4047 D->getLocation(), TU); 4048 4049 case Decl::UsingShadow: 4050 return clang_getCursorDefinition( 4051 MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(), 4052 TU)); 4053 4054 case Decl::ObjCMethod: { 4055 ObjCMethodDecl *Method = cast<ObjCMethodDecl>(D); 4056 if (Method->isThisDeclarationADefinition()) 4057 return C; 4058 4059 // Dig out the method definition in the associated 4060 // @implementation, if we have it. 4061 // FIXME: The ASTs should make finding the definition easier. 4062 if (ObjCInterfaceDecl *Class 4063 = dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) 4064 if (ObjCImplementationDecl *ClassImpl = Class->getImplementation()) 4065 if (ObjCMethodDecl *Def = ClassImpl->getMethod(Method->getSelector(), 4066 Method->isInstanceMethod())) 4067 if (Def->isThisDeclarationADefinition()) 4068 return MakeCXCursor(Def, TU); 4069 4070 return clang_getNullCursor(); 4071 } 4072 4073 case Decl::ObjCCategory: 4074 if (ObjCCategoryImplDecl *Impl 4075 = cast<ObjCCategoryDecl>(D)->getImplementation()) 4076 return MakeCXCursor(Impl, TU); 4077 return clang_getNullCursor(); 4078 4079 case Decl::ObjCProtocol: 4080 if (!cast<ObjCProtocolDecl>(D)->isForwardDecl()) 4081 return C; 4082 return clang_getNullCursor(); 4083 4084 case Decl::ObjCInterface: 4085 // There are two notions of a "definition" for an Objective-C 4086 // class: the interface and its implementation. When we resolved a 4087 // reference to an Objective-C class, produce the @interface as 4088 // the definition; when we were provided with the interface, 4089 // produce the @implementation as the definition. 4090 if (WasReference) { 4091 if (!cast<ObjCInterfaceDecl>(D)->isForwardDecl()) 4092 return C; 4093 } else if (ObjCImplementationDecl *Impl 4094 = cast<ObjCInterfaceDecl>(D)->getImplementation()) 4095 return MakeCXCursor(Impl, TU); 4096 return clang_getNullCursor(); 4097 4098 case Decl::ObjCProperty: 4099 // FIXME: We don't really know where to find the 4100 // ObjCPropertyImplDecls that implement this property. 4101 return clang_getNullCursor(); 4102 4103 case Decl::ObjCCompatibleAlias: 4104 if (ObjCInterfaceDecl *Class 4105 = cast<ObjCCompatibleAliasDecl>(D)->getClassInterface()) 4106 if (!Class->isForwardDecl()) 4107 return MakeCXCursor(Class, TU); 4108 4109 return clang_getNullCursor(); 4110 4111 case Decl::ObjCForwardProtocol: 4112 return MakeCursorOverloadedDeclRef(cast<ObjCForwardProtocolDecl>(D), 4113 D->getLocation(), TU); 4114 4115 case Decl::ObjCClass: 4116 return MakeCursorOverloadedDeclRef(cast<ObjCClassDecl>(D), D->getLocation(), 4117 TU); 4118 4119 case Decl::Friend: 4120 if (NamedDecl *Friend = cast<FriendDecl>(D)->getFriendDecl()) 4121 return clang_getCursorDefinition(MakeCXCursor(Friend, TU)); 4122 return clang_getNullCursor(); 4123 4124 case Decl::FriendTemplate: 4125 if (NamedDecl *Friend = cast<FriendTemplateDecl>(D)->getFriendDecl()) 4126 return clang_getCursorDefinition(MakeCXCursor(Friend, TU)); 4127 return clang_getNullCursor(); 4128 } 4129 4130 return clang_getNullCursor(); 4131} 4132 4133unsigned clang_isCursorDefinition(CXCursor C) { 4134 if (!clang_isDeclaration(C.kind)) 4135 return 0; 4136 4137 return clang_getCursorDefinition(C) == C; 4138} 4139 4140CXCursor clang_getCanonicalCursor(CXCursor C) { 4141 if (!clang_isDeclaration(C.kind)) 4142 return C; 4143 4144 if (Decl *D = getCursorDecl(C)) 4145 return MakeCXCursor(D->getCanonicalDecl(), getCursorTU(C)); 4146 4147 return C; 4148} 4149 4150unsigned clang_getNumOverloadedDecls(CXCursor C) { 4151 if (C.kind != CXCursor_OverloadedDeclRef) 4152 return 0; 4153 4154 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; 4155 if (OverloadExpr *E = Storage.dyn_cast<OverloadExpr *>()) 4156 return E->getNumDecls(); 4157 4158 if (OverloadedTemplateStorage *S 4159 = Storage.dyn_cast<OverloadedTemplateStorage*>()) 4160 return S->size(); 4161 4162 Decl *D = Storage.get<Decl*>(); 4163 if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) 4164 return Using->shadow_size(); 4165 if (ObjCClassDecl *Classes = dyn_cast<ObjCClassDecl>(D)) 4166 return Classes->size(); 4167 if (ObjCForwardProtocolDecl *Protocols =dyn_cast<ObjCForwardProtocolDecl>(D)) 4168 return Protocols->protocol_size(); 4169 4170 return 0; 4171} 4172 4173CXCursor clang_getOverloadedDecl(CXCursor cursor, unsigned index) { 4174 if (cursor.kind != CXCursor_OverloadedDeclRef) 4175 return clang_getNullCursor(); 4176 4177 if (index >= clang_getNumOverloadedDecls(cursor)) 4178 return clang_getNullCursor(); 4179 4180 CXTranslationUnit TU = getCursorTU(cursor); 4181 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(cursor).first; 4182 if (OverloadExpr *E = Storage.dyn_cast<OverloadExpr *>()) 4183 return MakeCXCursor(E->decls_begin()[index], TU); 4184 4185 if (OverloadedTemplateStorage *S 4186 = Storage.dyn_cast<OverloadedTemplateStorage*>()) 4187 return MakeCXCursor(S->begin()[index], TU); 4188 4189 Decl *D = Storage.get<Decl*>(); 4190 if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) { 4191 // FIXME: This is, unfortunately, linear time. 4192 UsingDecl::shadow_iterator Pos = Using->shadow_begin(); 4193 std::advance(Pos, index); 4194 return MakeCXCursor(cast<UsingShadowDecl>(*Pos)->getTargetDecl(), TU); 4195 } 4196 4197 if (ObjCClassDecl *Classes = dyn_cast<ObjCClassDecl>(D)) 4198 return MakeCXCursor(Classes->begin()[index].getInterface(), TU); 4199 4200 if (ObjCForwardProtocolDecl *Protocols = dyn_cast<ObjCForwardProtocolDecl>(D)) 4201 return MakeCXCursor(Protocols->protocol_begin()[index], TU); 4202 4203 return clang_getNullCursor(); 4204} 4205 4206void clang_getDefinitionSpellingAndExtent(CXCursor C, 4207 const char **startBuf, 4208 const char **endBuf, 4209 unsigned *startLine, 4210 unsigned *startColumn, 4211 unsigned *endLine, 4212 unsigned *endColumn) { 4213 assert(getCursorDecl(C) && "CXCursor has null decl"); 4214 NamedDecl *ND = static_cast<NamedDecl *>(getCursorDecl(C)); 4215 FunctionDecl *FD = dyn_cast<FunctionDecl>(ND); 4216 CompoundStmt *Body = dyn_cast<CompoundStmt>(FD->getBody()); 4217 4218 SourceManager &SM = FD->getASTContext().getSourceManager(); 4219 *startBuf = SM.getCharacterData(Body->getLBracLoc()); 4220 *endBuf = SM.getCharacterData(Body->getRBracLoc()); 4221 *startLine = SM.getSpellingLineNumber(Body->getLBracLoc()); 4222 *startColumn = SM.getSpellingColumnNumber(Body->getLBracLoc()); 4223 *endLine = SM.getSpellingLineNumber(Body->getRBracLoc()); 4224 *endColumn = SM.getSpellingColumnNumber(Body->getRBracLoc()); 4225} 4226 4227void clang_enableStackTraces(void) { 4228 llvm::sys::PrintStackTraceOnErrorSignal(); 4229} 4230 4231void clang_executeOnThread(void (*fn)(void*), void *user_data, 4232 unsigned stack_size) { 4233 llvm::llvm_execute_on_thread(fn, user_data, stack_size); 4234} 4235 4236} // end: extern "C" 4237 4238//===----------------------------------------------------------------------===// 4239// Token-based Operations. 4240//===----------------------------------------------------------------------===// 4241 4242/* CXToken layout: 4243 * int_data[0]: a CXTokenKind 4244 * int_data[1]: starting token location 4245 * int_data[2]: token length 4246 * int_data[3]: reserved 4247 * ptr_data: for identifiers and keywords, an IdentifierInfo*. 4248 * otherwise unused. 4249 */ 4250extern "C" { 4251 4252CXTokenKind clang_getTokenKind(CXToken CXTok) { 4253 return static_cast<CXTokenKind>(CXTok.int_data[0]); 4254} 4255 4256CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) { 4257 switch (clang_getTokenKind(CXTok)) { 4258 case CXToken_Identifier: 4259 case CXToken_Keyword: 4260 // We know we have an IdentifierInfo*, so use that. 4261 return createCXString(static_cast<IdentifierInfo *>(CXTok.ptr_data) 4262 ->getNameStart()); 4263 4264 case CXToken_Literal: { 4265 // We have stashed the starting pointer in the ptr_data field. Use it. 4266 const char *Text = static_cast<const char *>(CXTok.ptr_data); 4267 return createCXString(llvm::StringRef(Text, CXTok.int_data[2])); 4268 } 4269 4270 case CXToken_Punctuation: 4271 case CXToken_Comment: 4272 break; 4273 } 4274 4275 // We have to find the starting buffer pointer the hard way, by 4276 // deconstructing the source location. 4277 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4278 if (!CXXUnit) 4279 return createCXString(""); 4280 4281 SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]); 4282 std::pair<FileID, unsigned> LocInfo 4283 = CXXUnit->getSourceManager().getDecomposedLoc(Loc); 4284 bool Invalid = false; 4285 llvm::StringRef Buffer 4286 = CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid); 4287 if (Invalid) 4288 return createCXString(""); 4289 4290 return createCXString(Buffer.substr(LocInfo.second, CXTok.int_data[2])); 4291} 4292 4293CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) { 4294 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4295 if (!CXXUnit) 4296 return clang_getNullLocation(); 4297 4298 return cxloc::translateSourceLocation(CXXUnit->getASTContext(), 4299 SourceLocation::getFromRawEncoding(CXTok.int_data[1])); 4300} 4301 4302CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) { 4303 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4304 if (!CXXUnit) 4305 return clang_getNullRange(); 4306 4307 return cxloc::translateSourceRange(CXXUnit->getASTContext(), 4308 SourceLocation::getFromRawEncoding(CXTok.int_data[1])); 4309} 4310 4311void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range, 4312 CXToken **Tokens, unsigned *NumTokens) { 4313 if (Tokens) 4314 *Tokens = 0; 4315 if (NumTokens) 4316 *NumTokens = 0; 4317 4318 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4319 if (!CXXUnit || !Tokens || !NumTokens) 4320 return; 4321 4322 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 4323 4324 SourceRange R = cxloc::translateCXSourceRange(Range); 4325 if (R.isInvalid()) 4326 return; 4327 4328 SourceManager &SourceMgr = CXXUnit->getSourceManager(); 4329 std::pair<FileID, unsigned> BeginLocInfo 4330 = SourceMgr.getDecomposedLoc(R.getBegin()); 4331 std::pair<FileID, unsigned> EndLocInfo 4332 = SourceMgr.getDecomposedLoc(R.getEnd()); 4333 4334 // Cannot tokenize across files. 4335 if (BeginLocInfo.first != EndLocInfo.first) 4336 return; 4337 4338 // Create a lexer 4339 bool Invalid = false; 4340 llvm::StringRef Buffer 4341 = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid); 4342 if (Invalid) 4343 return; 4344 4345 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first), 4346 CXXUnit->getASTContext().getLangOptions(), 4347 Buffer.begin(), Buffer.data() + BeginLocInfo.second, Buffer.end()); 4348 Lex.SetCommentRetentionState(true); 4349 4350 // Lex tokens until we hit the end of the range. 4351 const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second; 4352 llvm::SmallVector<CXToken, 32> CXTokens; 4353 Token Tok; 4354 bool previousWasAt = false; 4355 do { 4356 // Lex the next token 4357 Lex.LexFromRawLexer(Tok); 4358 if (Tok.is(tok::eof)) 4359 break; 4360 4361 // Initialize the CXToken. 4362 CXToken CXTok; 4363 4364 // - Common fields 4365 CXTok.int_data[1] = Tok.getLocation().getRawEncoding(); 4366 CXTok.int_data[2] = Tok.getLength(); 4367 CXTok.int_data[3] = 0; 4368 4369 // - Kind-specific fields 4370 if (Tok.isLiteral()) { 4371 CXTok.int_data[0] = CXToken_Literal; 4372 CXTok.ptr_data = (void *)Tok.getLiteralData(); 4373 } else if (Tok.is(tok::raw_identifier)) { 4374 // Lookup the identifier to determine whether we have a keyword. 4375 IdentifierInfo *II 4376 = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok); 4377 4378 if ((II->getObjCKeywordID() != tok::objc_not_keyword) && previousWasAt) { 4379 CXTok.int_data[0] = CXToken_Keyword; 4380 } 4381 else { 4382 CXTok.int_data[0] = Tok.is(tok::identifier) 4383 ? CXToken_Identifier 4384 : CXToken_Keyword; 4385 } 4386 CXTok.ptr_data = II; 4387 } else if (Tok.is(tok::comment)) { 4388 CXTok.int_data[0] = CXToken_Comment; 4389 CXTok.ptr_data = 0; 4390 } else { 4391 CXTok.int_data[0] = CXToken_Punctuation; 4392 CXTok.ptr_data = 0; 4393 } 4394 CXTokens.push_back(CXTok); 4395 previousWasAt = Tok.is(tok::at); 4396 } while (Lex.getBufferLocation() <= EffectiveBufferEnd); 4397 4398 if (CXTokens.empty()) 4399 return; 4400 4401 *Tokens = (CXToken *)malloc(sizeof(CXToken) * CXTokens.size()); 4402 memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size()); 4403 *NumTokens = CXTokens.size(); 4404} 4405 4406void clang_disposeTokens(CXTranslationUnit TU, 4407 CXToken *Tokens, unsigned NumTokens) { 4408 free(Tokens); 4409} 4410 4411} // end: extern "C" 4412 4413//===----------------------------------------------------------------------===// 4414// Token annotation APIs. 4415//===----------------------------------------------------------------------===// 4416 4417typedef llvm::DenseMap<unsigned, CXCursor> AnnotateTokensData; 4418static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor, 4419 CXCursor parent, 4420 CXClientData client_data); 4421namespace { 4422class AnnotateTokensWorker { 4423 AnnotateTokensData &Annotated; 4424 CXToken *Tokens; 4425 CXCursor *Cursors; 4426 unsigned NumTokens; 4427 unsigned TokIdx; 4428 unsigned PreprocessingTokIdx; 4429 CursorVisitor AnnotateVis; 4430 SourceManager &SrcMgr; 4431 bool HasContextSensitiveKeywords; 4432 4433 bool MoreTokens() const { return TokIdx < NumTokens; } 4434 unsigned NextToken() const { return TokIdx; } 4435 void AdvanceToken() { ++TokIdx; } 4436 SourceLocation GetTokenLoc(unsigned tokI) { 4437 return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[1]); 4438 } 4439 4440public: 4441 AnnotateTokensWorker(AnnotateTokensData &annotated, 4442 CXToken *tokens, CXCursor *cursors, unsigned numTokens, 4443 CXTranslationUnit tu, SourceRange RegionOfInterest) 4444 : Annotated(annotated), Tokens(tokens), Cursors(cursors), 4445 NumTokens(numTokens), TokIdx(0), PreprocessingTokIdx(0), 4446 AnnotateVis(tu, 4447 AnnotateTokensVisitor, this, 4448 Decl::MaxPCHLevel, true, RegionOfInterest), 4449 SrcMgr(static_cast<ASTUnit*>(tu->TUData)->getSourceManager()), 4450 HasContextSensitiveKeywords(false) { } 4451 4452 void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); } 4453 enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent); 4454 void AnnotateTokens(CXCursor parent); 4455 void AnnotateTokens() { 4456 AnnotateTokens(clang_getTranslationUnitCursor(AnnotateVis.getTU())); 4457 } 4458 4459 /// \brief Determine whether the annotator saw any cursors that have 4460 /// context-sensitive keywords. 4461 bool hasContextSensitiveKeywords() const { 4462 return HasContextSensitiveKeywords; 4463 } 4464}; 4465} 4466 4467void AnnotateTokensWorker::AnnotateTokens(CXCursor parent) { 4468 // Walk the AST within the region of interest, annotating tokens 4469 // along the way. 4470 VisitChildren(parent); 4471 4472 for (unsigned I = 0 ; I < TokIdx ; ++I) { 4473 AnnotateTokensData::iterator Pos = Annotated.find(Tokens[I].int_data[1]); 4474 if (Pos != Annotated.end() && 4475 (clang_isInvalid(Cursors[I].kind) || 4476 Pos->second.kind != CXCursor_PreprocessingDirective)) 4477 Cursors[I] = Pos->second; 4478 } 4479 4480 // Finish up annotating any tokens left. 4481 if (!MoreTokens()) 4482 return; 4483 4484 const CXCursor &C = clang_getNullCursor(); 4485 for (unsigned I = TokIdx ; I < NumTokens ; ++I) { 4486 AnnotateTokensData::iterator Pos = Annotated.find(Tokens[I].int_data[1]); 4487 Cursors[I] = (Pos == Annotated.end()) ? C : Pos->second; 4488 } 4489} 4490 4491enum CXChildVisitResult 4492AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) { 4493 CXSourceLocation Loc = clang_getCursorLocation(cursor); 4494 SourceRange cursorRange = getRawCursorExtent(cursor); 4495 if (cursorRange.isInvalid()) 4496 return CXChildVisit_Recurse; 4497 4498 if (!HasContextSensitiveKeywords) { 4499 // Objective-C properties can have context-sensitive keywords. 4500 if (cursor.kind == CXCursor_ObjCPropertyDecl) { 4501 if (ObjCPropertyDecl *Property 4502 = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(cursor))) 4503 HasContextSensitiveKeywords = Property->getPropertyAttributesAsWritten() != 0; 4504 } 4505 // Objective-C methods can have context-sensitive keywords. 4506 else if (cursor.kind == CXCursor_ObjCInstanceMethodDecl || 4507 cursor.kind == CXCursor_ObjCClassMethodDecl) { 4508 if (ObjCMethodDecl *Method 4509 = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) { 4510 if (Method->getObjCDeclQualifier()) 4511 HasContextSensitiveKeywords = true; 4512 else { 4513 for (ObjCMethodDecl::param_iterator P = Method->param_begin(), 4514 PEnd = Method->param_end(); 4515 P != PEnd; ++P) { 4516 if ((*P)->getObjCDeclQualifier()) { 4517 HasContextSensitiveKeywords = true; 4518 break; 4519 } 4520 } 4521 } 4522 } 4523 } 4524 // C++ methods can have context-sensitive keywords. 4525 else if (cursor.kind == CXCursor_CXXMethod) { 4526 if (CXXMethodDecl *Method 4527 = dyn_cast_or_null<CXXMethodDecl>(getCursorDecl(cursor))) { 4528 if (Method->hasAttr<FinalAttr>() || Method->hasAttr<OverrideAttr>()) 4529 HasContextSensitiveKeywords = true; 4530 } 4531 } 4532 // C++ classes can have context-sensitive keywords. 4533 else if (cursor.kind == CXCursor_StructDecl || 4534 cursor.kind == CXCursor_ClassDecl || 4535 cursor.kind == CXCursor_ClassTemplate || 4536 cursor.kind == CXCursor_ClassTemplatePartialSpecialization) { 4537 if (Decl *D = getCursorDecl(cursor)) 4538 if (D->hasAttr<FinalAttr>()) 4539 HasContextSensitiveKeywords = true; 4540 } 4541 } 4542 4543 if (clang_isPreprocessing(cursor.kind)) { 4544 // For macro instantiations, just note where the beginning of the macro 4545 // instantiation occurs. 4546 if (cursor.kind == CXCursor_MacroInstantiation) { 4547 Annotated[Loc.int_data] = cursor; 4548 return CXChildVisit_Recurse; 4549 } 4550 4551 // Items in the preprocessing record are kept separate from items in 4552 // declarations, so we keep a separate token index. 4553 unsigned SavedTokIdx = TokIdx; 4554 TokIdx = PreprocessingTokIdx; 4555 4556 // Skip tokens up until we catch up to the beginning of the preprocessing 4557 // entry. 4558 while (MoreTokens()) { 4559 const unsigned I = NextToken(); 4560 SourceLocation TokLoc = GetTokenLoc(I); 4561 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 4562 case RangeBefore: 4563 AdvanceToken(); 4564 continue; 4565 case RangeAfter: 4566 case RangeOverlap: 4567 break; 4568 } 4569 break; 4570 } 4571 4572 // Look at all of the tokens within this range. 4573 while (MoreTokens()) { 4574 const unsigned I = NextToken(); 4575 SourceLocation TokLoc = GetTokenLoc(I); 4576 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 4577 case RangeBefore: 4578 assert(0 && "Infeasible"); 4579 case RangeAfter: 4580 break; 4581 case RangeOverlap: 4582 Cursors[I] = cursor; 4583 AdvanceToken(); 4584 continue; 4585 } 4586 break; 4587 } 4588 4589 // Save the preprocessing token index; restore the non-preprocessing 4590 // token index. 4591 PreprocessingTokIdx = TokIdx; 4592 TokIdx = SavedTokIdx; 4593 return CXChildVisit_Recurse; 4594 } 4595 4596 if (cursorRange.isInvalid()) 4597 return CXChildVisit_Continue; 4598 4599 SourceLocation L = SourceLocation::getFromRawEncoding(Loc.int_data); 4600 4601 // Adjust the annotated range based specific declarations. 4602 const enum CXCursorKind cursorK = clang_getCursorKind(cursor); 4603 if (cursorK >= CXCursor_FirstDecl && cursorK <= CXCursor_LastDecl) { 4604 Decl *D = cxcursor::getCursorDecl(cursor); 4605 // Don't visit synthesized ObjC methods, since they have no syntatic 4606 // representation in the source. 4607 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { 4608 if (MD->isSynthesized()) 4609 return CXChildVisit_Continue; 4610 } 4611 4612 SourceLocation StartLoc; 4613 if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) { 4614 if (TypeSourceInfo *TI = DD->getTypeSourceInfo()) 4615 StartLoc = TI->getTypeLoc().getSourceRange().getBegin(); 4616 } else if (TypedefDecl *Typedef = dyn_cast<TypedefDecl>(D)) { 4617 if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo()) 4618 StartLoc = TI->getTypeLoc().getSourceRange().getBegin(); 4619 } 4620 4621 if (StartLoc.isValid() && L.isValid() && 4622 SrcMgr.isBeforeInTranslationUnit(StartLoc, L)) 4623 cursorRange.setBegin(StartLoc); 4624 } 4625 4626 // If the location of the cursor occurs within a macro instantiation, record 4627 // the spelling location of the cursor in our annotation map. We can then 4628 // paper over the token labelings during a post-processing step to try and 4629 // get cursor mappings for tokens that are the *arguments* of a macro 4630 // instantiation. 4631 if (L.isMacroID()) { 4632 unsigned rawEncoding = SrcMgr.getSpellingLoc(L).getRawEncoding(); 4633 // Only invalidate the old annotation if it isn't part of a preprocessing 4634 // directive. Here we assume that the default construction of CXCursor 4635 // results in CXCursor.kind being an initialized value (i.e., 0). If 4636 // this isn't the case, we can fix by doing lookup + insertion. 4637 4638 CXCursor &oldC = Annotated[rawEncoding]; 4639 if (!clang_isPreprocessing(oldC.kind)) 4640 oldC = cursor; 4641 } 4642 4643 const enum CXCursorKind K = clang_getCursorKind(parent); 4644 const CXCursor updateC = 4645 (clang_isInvalid(K) || K == CXCursor_TranslationUnit) 4646 ? clang_getNullCursor() : parent; 4647 4648 while (MoreTokens()) { 4649 const unsigned I = NextToken(); 4650 SourceLocation TokLoc = GetTokenLoc(I); 4651 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 4652 case RangeBefore: 4653 Cursors[I] = updateC; 4654 AdvanceToken(); 4655 continue; 4656 case RangeAfter: 4657 case RangeOverlap: 4658 break; 4659 } 4660 break; 4661 } 4662 4663 // Avoid having the cursor of an expression "overwrite" the annotation of the 4664 // variable declaration that it belongs to. 4665 // This can happen for C++ constructor expressions whose range generally 4666 // include the variable declaration, e.g.: 4667 // MyCXXClass foo; // Make sure we don't annotate 'foo' as a CallExpr cursor. 4668 if (clang_isExpression(cursorK)) { 4669 Expr *E = getCursorExpr(cursor); 4670 if (Decl *D = getCursorParentDecl(cursor)) { 4671 const unsigned I = NextToken(); 4672 if (E->getLocStart().isValid() && D->getLocation().isValid() && 4673 E->getLocStart() == D->getLocation() && 4674 E->getLocStart() == GetTokenLoc(I)) { 4675 Cursors[I] = updateC; 4676 AdvanceToken(); 4677 } 4678 } 4679 } 4680 4681 // Visit children to get their cursor information. 4682 const unsigned BeforeChildren = NextToken(); 4683 VisitChildren(cursor); 4684 const unsigned AfterChildren = NextToken(); 4685 4686 // Adjust 'Last' to the last token within the extent of the cursor. 4687 while (MoreTokens()) { 4688 const unsigned I = NextToken(); 4689 SourceLocation TokLoc = GetTokenLoc(I); 4690 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 4691 case RangeBefore: 4692 assert(0 && "Infeasible"); 4693 case RangeAfter: 4694 break; 4695 case RangeOverlap: 4696 Cursors[I] = updateC; 4697 AdvanceToken(); 4698 continue; 4699 } 4700 break; 4701 } 4702 const unsigned Last = NextToken(); 4703 4704 // Scan the tokens that are at the beginning of the cursor, but are not 4705 // capture by the child cursors. 4706 4707 // For AST elements within macros, rely on a post-annotate pass to 4708 // to correctly annotate the tokens with cursors. Otherwise we can 4709 // get confusing results of having tokens that map to cursors that really 4710 // are expanded by an instantiation. 4711 if (L.isMacroID()) 4712 cursor = clang_getNullCursor(); 4713 4714 for (unsigned I = BeforeChildren; I != AfterChildren; ++I) { 4715 if (!clang_isInvalid(clang_getCursorKind(Cursors[I]))) 4716 break; 4717 4718 Cursors[I] = cursor; 4719 } 4720 // Scan the tokens that are at the end of the cursor, but are not captured 4721 // but the child cursors. 4722 for (unsigned I = AfterChildren; I != Last; ++I) 4723 Cursors[I] = cursor; 4724 4725 TokIdx = Last; 4726 return CXChildVisit_Continue; 4727} 4728 4729static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor, 4730 CXCursor parent, 4731 CXClientData client_data) { 4732 return static_cast<AnnotateTokensWorker*>(client_data)->Visit(cursor, parent); 4733} 4734 4735namespace { 4736 struct clang_annotateTokens_Data { 4737 CXTranslationUnit TU; 4738 ASTUnit *CXXUnit; 4739 CXToken *Tokens; 4740 unsigned NumTokens; 4741 CXCursor *Cursors; 4742 }; 4743} 4744 4745// This gets run a separate thread to avoid stack blowout. 4746static void clang_annotateTokensImpl(void *UserData) { 4747 CXTranslationUnit TU = ((clang_annotateTokens_Data*)UserData)->TU; 4748 ASTUnit *CXXUnit = ((clang_annotateTokens_Data*)UserData)->CXXUnit; 4749 CXToken *Tokens = ((clang_annotateTokens_Data*)UserData)->Tokens; 4750 const unsigned NumTokens = ((clang_annotateTokens_Data*)UserData)->NumTokens; 4751 CXCursor *Cursors = ((clang_annotateTokens_Data*)UserData)->Cursors; 4752 4753 // Determine the region of interest, which contains all of the tokens. 4754 SourceRange RegionOfInterest; 4755 RegionOfInterest.setBegin( 4756 cxloc::translateSourceLocation(clang_getTokenLocation(TU, Tokens[0]))); 4757 RegionOfInterest.setEnd( 4758 cxloc::translateSourceLocation(clang_getTokenLocation(TU, 4759 Tokens[NumTokens-1]))); 4760 4761 // A mapping from the source locations found when re-lexing or traversing the 4762 // region of interest to the corresponding cursors. 4763 AnnotateTokensData Annotated; 4764 4765 // Relex the tokens within the source range to look for preprocessing 4766 // directives. 4767 SourceManager &SourceMgr = CXXUnit->getSourceManager(); 4768 std::pair<FileID, unsigned> BeginLocInfo 4769 = SourceMgr.getDecomposedLoc(RegionOfInterest.getBegin()); 4770 std::pair<FileID, unsigned> EndLocInfo 4771 = SourceMgr.getDecomposedLoc(RegionOfInterest.getEnd()); 4772 4773 llvm::StringRef Buffer; 4774 bool Invalid = false; 4775 if (BeginLocInfo.first == EndLocInfo.first && 4776 ((Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid)),true) && 4777 !Invalid) { 4778 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first), 4779 CXXUnit->getASTContext().getLangOptions(), 4780 Buffer.begin(), Buffer.data() + BeginLocInfo.second, 4781 Buffer.end()); 4782 Lex.SetCommentRetentionState(true); 4783 4784 // Lex tokens in raw mode until we hit the end of the range, to avoid 4785 // entering #includes or expanding macros. 4786 while (true) { 4787 Token Tok; 4788 Lex.LexFromRawLexer(Tok); 4789 4790 reprocess: 4791 if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) { 4792 // We have found a preprocessing directive. Gobble it up so that we 4793 // don't see it while preprocessing these tokens later, but keep track 4794 // of all of the token locations inside this preprocessing directive so 4795 // that we can annotate them appropriately. 4796 // 4797 // FIXME: Some simple tests here could identify macro definitions and 4798 // #undefs, to provide specific cursor kinds for those. 4799 llvm::SmallVector<SourceLocation, 32> Locations; 4800 do { 4801 Locations.push_back(Tok.getLocation()); 4802 Lex.LexFromRawLexer(Tok); 4803 } while (!Tok.isAtStartOfLine() && !Tok.is(tok::eof)); 4804 4805 using namespace cxcursor; 4806 CXCursor Cursor 4807 = MakePreprocessingDirectiveCursor(SourceRange(Locations.front(), 4808 Locations.back()), 4809 TU); 4810 for (unsigned I = 0, N = Locations.size(); I != N; ++I) { 4811 Annotated[Locations[I].getRawEncoding()] = Cursor; 4812 } 4813 4814 if (Tok.isAtStartOfLine()) 4815 goto reprocess; 4816 4817 continue; 4818 } 4819 4820 if (Tok.is(tok::eof)) 4821 break; 4822 } 4823 } 4824 4825 // Annotate all of the source locations in the region of interest that map to 4826 // a specific cursor. 4827 AnnotateTokensWorker W(Annotated, Tokens, Cursors, NumTokens, 4828 TU, RegionOfInterest); 4829 4830 // FIXME: We use a ridiculous stack size here because the data-recursion 4831 // algorithm uses a large stack frame than the non-data recursive version, 4832 // and AnnotationTokensWorker currently transforms the data-recursion 4833 // algorithm back into a traditional recursion by explicitly calling 4834 // VisitChildren(). We will need to remove this explicit recursive call. 4835 W.AnnotateTokens(); 4836 4837 // If we ran into any entities that involve context-sensitive keywords, 4838 // take another pass through the tokens to mark them as such. 4839 if (W.hasContextSensitiveKeywords()) { 4840 for (unsigned I = 0; I != NumTokens; ++I) { 4841 if (clang_getTokenKind(Tokens[I]) != CXToken_Identifier) 4842 continue; 4843 4844 if (Cursors[I].kind == CXCursor_ObjCPropertyDecl) { 4845 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 4846 if (ObjCPropertyDecl *Property 4847 = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(Cursors[I]))) { 4848 if (Property->getPropertyAttributesAsWritten() != 0 && 4849 llvm::StringSwitch<bool>(II->getName()) 4850 .Case("readonly", true) 4851 .Case("assign", true) 4852 .Case("unsafe_unretained", true) 4853 .Case("readwrite", true) 4854 .Case("retain", true) 4855 .Case("copy", true) 4856 .Case("nonatomic", true) 4857 .Case("atomic", true) 4858 .Case("getter", true) 4859 .Case("setter", true) 4860 .Case("strong", true) 4861 .Case("weak", true) 4862 .Default(false)) 4863 Tokens[I].int_data[0] = CXToken_Keyword; 4864 } 4865 continue; 4866 } 4867 4868 if (Cursors[I].kind == CXCursor_ObjCInstanceMethodDecl || 4869 Cursors[I].kind == CXCursor_ObjCClassMethodDecl) { 4870 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 4871 if (llvm::StringSwitch<bool>(II->getName()) 4872 .Case("in", true) 4873 .Case("out", true) 4874 .Case("inout", true) 4875 .Case("oneway", true) 4876 .Case("bycopy", true) 4877 .Case("byref", true) 4878 .Default(false)) 4879 Tokens[I].int_data[0] = CXToken_Keyword; 4880 continue; 4881 } 4882 4883 if (Cursors[I].kind == CXCursor_CXXMethod) { 4884 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 4885 if (CXXMethodDecl *Method 4886 = dyn_cast_or_null<CXXMethodDecl>(getCursorDecl(Cursors[I]))) { 4887 if ((Method->hasAttr<FinalAttr>() || 4888 Method->hasAttr<OverrideAttr>()) && 4889 Method->getLocation().getRawEncoding() != Tokens[I].int_data[1] && 4890 llvm::StringSwitch<bool>(II->getName()) 4891 .Case("final", true) 4892 .Case("override", true) 4893 .Default(false)) 4894 Tokens[I].int_data[0] = CXToken_Keyword; 4895 } 4896 continue; 4897 } 4898 4899 if (Cursors[I].kind == CXCursor_ClassDecl || 4900 Cursors[I].kind == CXCursor_StructDecl || 4901 Cursors[I].kind == CXCursor_ClassTemplate) { 4902 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 4903 if (II->getName() == "final") { 4904 // We have to be careful with 'final', since it could be the name 4905 // of a member class rather than the context-sensitive keyword. 4906 // So, check whether the cursor associated with this 4907 Decl *D = getCursorDecl(Cursors[I]); 4908 if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(D)) { 4909 if ((Record->hasAttr<FinalAttr>()) && 4910 Record->getIdentifier() != II) 4911 Tokens[I].int_data[0] = CXToken_Keyword; 4912 } else if (ClassTemplateDecl *ClassTemplate 4913 = dyn_cast_or_null<ClassTemplateDecl>(D)) { 4914 CXXRecordDecl *Record = ClassTemplate->getTemplatedDecl(); 4915 if ((Record->hasAttr<FinalAttr>()) && 4916 Record->getIdentifier() != II) 4917 Tokens[I].int_data[0] = CXToken_Keyword; 4918 } 4919 } 4920 continue; 4921 } 4922 } 4923 } 4924} 4925 4926extern "C" { 4927 4928void clang_annotateTokens(CXTranslationUnit TU, 4929 CXToken *Tokens, unsigned NumTokens, 4930 CXCursor *Cursors) { 4931 4932 if (NumTokens == 0 || !Tokens || !Cursors) 4933 return; 4934 4935 // Any token we don't specifically annotate will have a NULL cursor. 4936 CXCursor C = clang_getNullCursor(); 4937 for (unsigned I = 0; I != NumTokens; ++I) 4938 Cursors[I] = C; 4939 4940 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4941 if (!CXXUnit) 4942 return; 4943 4944 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 4945 4946 clang_annotateTokens_Data data = { TU, CXXUnit, Tokens, NumTokens, Cursors }; 4947 llvm::CrashRecoveryContext CRC; 4948 if (!RunSafely(CRC, clang_annotateTokensImpl, &data, 4949 GetSafetyThreadStackSize() * 2)) { 4950 fprintf(stderr, "libclang: crash detected while annotating tokens\n"); 4951 } 4952} 4953 4954} // end: extern "C" 4955 4956//===----------------------------------------------------------------------===// 4957// Operations for querying linkage of a cursor. 4958//===----------------------------------------------------------------------===// 4959 4960extern "C" { 4961CXLinkageKind clang_getCursorLinkage(CXCursor cursor) { 4962 if (!clang_isDeclaration(cursor.kind)) 4963 return CXLinkage_Invalid; 4964 4965 Decl *D = cxcursor::getCursorDecl(cursor); 4966 if (NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D)) 4967 switch (ND->getLinkage()) { 4968 case NoLinkage: return CXLinkage_NoLinkage; 4969 case InternalLinkage: return CXLinkage_Internal; 4970 case UniqueExternalLinkage: return CXLinkage_UniqueExternal; 4971 case ExternalLinkage: return CXLinkage_External; 4972 }; 4973 4974 return CXLinkage_Invalid; 4975} 4976} // end: extern "C" 4977 4978//===----------------------------------------------------------------------===// 4979// Operations for querying language of a cursor. 4980//===----------------------------------------------------------------------===// 4981 4982static CXLanguageKind getDeclLanguage(const Decl *D) { 4983 switch (D->getKind()) { 4984 default: 4985 break; 4986 case Decl::ImplicitParam: 4987 case Decl::ObjCAtDefsField: 4988 case Decl::ObjCCategory: 4989 case Decl::ObjCCategoryImpl: 4990 case Decl::ObjCClass: 4991 case Decl::ObjCCompatibleAlias: 4992 case Decl::ObjCForwardProtocol: 4993 case Decl::ObjCImplementation: 4994 case Decl::ObjCInterface: 4995 case Decl::ObjCIvar: 4996 case Decl::ObjCMethod: 4997 case Decl::ObjCProperty: 4998 case Decl::ObjCPropertyImpl: 4999 case Decl::ObjCProtocol: 5000 return CXLanguage_ObjC; 5001 case Decl::CXXConstructor: 5002 case Decl::CXXConversion: 5003 case Decl::CXXDestructor: 5004 case Decl::CXXMethod: 5005 case Decl::CXXRecord: 5006 case Decl::ClassTemplate: 5007 case Decl::ClassTemplatePartialSpecialization: 5008 case Decl::ClassTemplateSpecialization: 5009 case Decl::Friend: 5010 case Decl::FriendTemplate: 5011 case Decl::FunctionTemplate: 5012 case Decl::LinkageSpec: 5013 case Decl::Namespace: 5014 case Decl::NamespaceAlias: 5015 case Decl::NonTypeTemplateParm: 5016 case Decl::StaticAssert: 5017 case Decl::TemplateTemplateParm: 5018 case Decl::TemplateTypeParm: 5019 case Decl::UnresolvedUsingTypename: 5020 case Decl::UnresolvedUsingValue: 5021 case Decl::Using: 5022 case Decl::UsingDirective: 5023 case Decl::UsingShadow: 5024 return CXLanguage_CPlusPlus; 5025 } 5026 5027 return CXLanguage_C; 5028} 5029 5030extern "C" { 5031 5032enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor) { 5033 if (clang_isDeclaration(cursor.kind)) 5034 if (Decl *D = cxcursor::getCursorDecl(cursor)) { 5035 if (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isDeleted()) 5036 return CXAvailability_Available; 5037 5038 switch (D->getAvailability()) { 5039 case AR_Available: 5040 case AR_NotYetIntroduced: 5041 return CXAvailability_Available; 5042 5043 case AR_Deprecated: 5044 return CXAvailability_Deprecated; 5045 5046 case AR_Unavailable: 5047 return CXAvailability_NotAvailable; 5048 } 5049 } 5050 5051 return CXAvailability_Available; 5052} 5053 5054CXLanguageKind clang_getCursorLanguage(CXCursor cursor) { 5055 if (clang_isDeclaration(cursor.kind)) 5056 return getDeclLanguage(cxcursor::getCursorDecl(cursor)); 5057 5058 return CXLanguage_Invalid; 5059} 5060 5061 /// \brief If the given cursor is the "templated" declaration 5062 /// descibing a class or function template, return the class or 5063 /// function template. 5064static Decl *maybeGetTemplateCursor(Decl *D) { 5065 if (!D) 5066 return 0; 5067 5068 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 5069 if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate()) 5070 return FunTmpl; 5071 5072 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) 5073 if (ClassTemplateDecl *ClassTmpl = RD->getDescribedClassTemplate()) 5074 return ClassTmpl; 5075 5076 return D; 5077} 5078 5079CXCursor clang_getCursorSemanticParent(CXCursor cursor) { 5080 if (clang_isDeclaration(cursor.kind)) { 5081 if (Decl *D = getCursorDecl(cursor)) { 5082 DeclContext *DC = D->getDeclContext(); 5083 if (!DC) 5084 return clang_getNullCursor(); 5085 5086 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 5087 getCursorTU(cursor)); 5088 } 5089 } 5090 5091 if (clang_isStatement(cursor.kind) || clang_isExpression(cursor.kind)) { 5092 if (Decl *D = getCursorDecl(cursor)) 5093 return MakeCXCursor(D, getCursorTU(cursor)); 5094 } 5095 5096 return clang_getNullCursor(); 5097} 5098 5099CXCursor clang_getCursorLexicalParent(CXCursor cursor) { 5100 if (clang_isDeclaration(cursor.kind)) { 5101 if (Decl *D = getCursorDecl(cursor)) { 5102 DeclContext *DC = D->getLexicalDeclContext(); 5103 if (!DC) 5104 return clang_getNullCursor(); 5105 5106 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 5107 getCursorTU(cursor)); 5108 } 5109 } 5110 5111 // FIXME: Note that we can't easily compute the lexical context of a 5112 // statement or expression, so we return nothing. 5113 return clang_getNullCursor(); 5114} 5115 5116static void CollectOverriddenMethods(DeclContext *Ctx, 5117 ObjCMethodDecl *Method, 5118 llvm::SmallVectorImpl<ObjCMethodDecl *> &Methods) { 5119 if (!Ctx) 5120 return; 5121 5122 // If we have a class or category implementation, jump straight to the 5123 // interface. 5124 if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(Ctx)) 5125 return CollectOverriddenMethods(Impl->getClassInterface(), Method, Methods); 5126 5127 ObjCContainerDecl *Container = dyn_cast<ObjCContainerDecl>(Ctx); 5128 if (!Container) 5129 return; 5130 5131 // Check whether we have a matching method at this level. 5132 if (ObjCMethodDecl *Overridden = Container->getMethod(Method->getSelector(), 5133 Method->isInstanceMethod())) 5134 if (Method != Overridden) { 5135 // We found an override at this level; there is no need to look 5136 // into other protocols or categories. 5137 Methods.push_back(Overridden); 5138 return; 5139 } 5140 5141 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { 5142 for (ObjCProtocolDecl::protocol_iterator P = Protocol->protocol_begin(), 5143 PEnd = Protocol->protocol_end(); 5144 P != PEnd; ++P) 5145 CollectOverriddenMethods(*P, Method, Methods); 5146 } 5147 5148 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) { 5149 for (ObjCCategoryDecl::protocol_iterator P = Category->protocol_begin(), 5150 PEnd = Category->protocol_end(); 5151 P != PEnd; ++P) 5152 CollectOverriddenMethods(*P, Method, Methods); 5153 } 5154 5155 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) { 5156 for (ObjCInterfaceDecl::protocol_iterator P = Interface->protocol_begin(), 5157 PEnd = Interface->protocol_end(); 5158 P != PEnd; ++P) 5159 CollectOverriddenMethods(*P, Method, Methods); 5160 5161 for (ObjCCategoryDecl *Category = Interface->getCategoryList(); 5162 Category; Category = Category->getNextClassCategory()) 5163 CollectOverriddenMethods(Category, Method, Methods); 5164 5165 // We only look into the superclass if we haven't found anything yet. 5166 if (Methods.empty()) 5167 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) 5168 return CollectOverriddenMethods(Super, Method, Methods); 5169 } 5170} 5171 5172void clang_getOverriddenCursors(CXCursor cursor, 5173 CXCursor **overridden, 5174 unsigned *num_overridden) { 5175 if (overridden) 5176 *overridden = 0; 5177 if (num_overridden) 5178 *num_overridden = 0; 5179 if (!overridden || !num_overridden) 5180 return; 5181 5182 if (!clang_isDeclaration(cursor.kind)) 5183 return; 5184 5185 Decl *D = getCursorDecl(cursor); 5186 if (!D) 5187 return; 5188 5189 // Handle C++ member functions. 5190 CXTranslationUnit TU = getCursorTU(cursor); 5191 if (CXXMethodDecl *CXXMethod = dyn_cast<CXXMethodDecl>(D)) { 5192 *num_overridden = CXXMethod->size_overridden_methods(); 5193 if (!*num_overridden) 5194 return; 5195 5196 *overridden = new CXCursor [*num_overridden]; 5197 unsigned I = 0; 5198 for (CXXMethodDecl::method_iterator 5199 M = CXXMethod->begin_overridden_methods(), 5200 MEnd = CXXMethod->end_overridden_methods(); 5201 M != MEnd; (void)++M, ++I) 5202 (*overridden)[I] = MakeCXCursor(const_cast<CXXMethodDecl*>(*M), TU); 5203 return; 5204 } 5205 5206 ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D); 5207 if (!Method) 5208 return; 5209 5210 // Handle Objective-C methods. 5211 llvm::SmallVector<ObjCMethodDecl *, 4> Methods; 5212 CollectOverriddenMethods(Method->getDeclContext(), Method, Methods); 5213 5214 if (Methods.empty()) 5215 return; 5216 5217 *num_overridden = Methods.size(); 5218 *overridden = new CXCursor [Methods.size()]; 5219 for (unsigned I = 0, N = Methods.size(); I != N; ++I) 5220 (*overridden)[I] = MakeCXCursor(Methods[I], TU); 5221} 5222 5223void clang_disposeOverriddenCursors(CXCursor *overridden) { 5224 delete [] overridden; 5225} 5226 5227CXFile clang_getIncludedFile(CXCursor cursor) { 5228 if (cursor.kind != CXCursor_InclusionDirective) 5229 return 0; 5230 5231 InclusionDirective *ID = getCursorInclusionDirective(cursor); 5232 return (void *)ID->getFile(); 5233} 5234 5235} // end: extern "C" 5236 5237 5238//===----------------------------------------------------------------------===// 5239// C++ AST instrospection. 5240//===----------------------------------------------------------------------===// 5241 5242extern "C" { 5243unsigned clang_CXXMethod_isStatic(CXCursor C) { 5244 if (!clang_isDeclaration(C.kind)) 5245 return 0; 5246 5247 CXXMethodDecl *Method = 0; 5248 Decl *D = cxcursor::getCursorDecl(C); 5249 if (FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(D)) 5250 Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl()); 5251 else 5252 Method = dyn_cast_or_null<CXXMethodDecl>(D); 5253 return (Method && Method->isStatic()) ? 1 : 0; 5254} 5255 5256unsigned clang_CXXMethod_isVirtual(CXCursor C) { 5257 if (!clang_isDeclaration(C.kind)) 5258 return 0; 5259 5260 CXXMethodDecl *Method = 0; 5261 Decl *D = cxcursor::getCursorDecl(C); 5262 if (FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(D)) 5263 Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl()); 5264 else 5265 Method = dyn_cast_or_null<CXXMethodDecl>(D); 5266 return (Method && Method->isVirtual()) ? 1 : 0; 5267} 5268 5269} // end: extern "C" 5270 5271//===----------------------------------------------------------------------===// 5272// Attribute introspection. 5273//===----------------------------------------------------------------------===// 5274 5275extern "C" { 5276CXType clang_getIBOutletCollectionType(CXCursor C) { 5277 if (C.kind != CXCursor_IBOutletCollectionAttr) 5278 return cxtype::MakeCXType(QualType(), cxcursor::getCursorTU(C)); 5279 5280 IBOutletCollectionAttr *A = 5281 cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(C)); 5282 5283 return cxtype::MakeCXType(A->getInterFace(), cxcursor::getCursorTU(C)); 5284} 5285} // end: extern "C" 5286 5287//===----------------------------------------------------------------------===// 5288// Inspecting memory usage. 5289//===----------------------------------------------------------------------===// 5290 5291typedef std::vector<CXTUResourceUsageEntry> MemUsageEntries; 5292 5293static inline void createCXTUResourceUsageEntry(MemUsageEntries &entries, 5294 enum CXTUResourceUsageKind k, 5295 unsigned long amount) { 5296 CXTUResourceUsageEntry entry = { k, amount }; 5297 entries.push_back(entry); 5298} 5299 5300extern "C" { 5301 5302const char *clang_getTUResourceUsageName(CXTUResourceUsageKind kind) { 5303 const char *str = ""; 5304 switch (kind) { 5305 case CXTUResourceUsage_AST: 5306 str = "ASTContext: expressions, declarations, and types"; 5307 break; 5308 case CXTUResourceUsage_Identifiers: 5309 str = "ASTContext: identifiers"; 5310 break; 5311 case CXTUResourceUsage_Selectors: 5312 str = "ASTContext: selectors"; 5313 break; 5314 case CXTUResourceUsage_GlobalCompletionResults: 5315 str = "Code completion: cached global results"; 5316 break; 5317 case CXTUResourceUsage_SourceManagerContentCache: 5318 str = "SourceManager: content cache allocator"; 5319 break; 5320 case CXTUResourceUsage_AST_SideTables: 5321 str = "ASTContext: side tables"; 5322 break; 5323 case CXTUResourceUsage_SourceManager_Membuffer_Malloc: 5324 str = "SourceManager: malloc'ed memory buffers"; 5325 break; 5326 case CXTUResourceUsage_SourceManager_Membuffer_MMap: 5327 str = "SourceManager: mmap'ed memory buffers"; 5328 break; 5329 case CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc: 5330 str = "ExternalASTSource: malloc'ed memory buffers"; 5331 break; 5332 case CXTUResourceUsage_ExternalASTSource_Membuffer_MMap: 5333 str = "ExternalASTSource: mmap'ed memory buffers"; 5334 break; 5335 case CXTUResourceUsage_Preprocessor: 5336 str = "Preprocessor: malloc'ed memory"; 5337 break; 5338 case CXTUResourceUsage_PreprocessingRecord: 5339 str = "Preprocessor: PreprocessingRecord"; 5340 break; 5341 } 5342 return str; 5343} 5344 5345CXTUResourceUsage clang_getCXTUResourceUsage(CXTranslationUnit TU) { 5346 if (!TU) { 5347 CXTUResourceUsage usage = { (void*) 0, 0, 0 }; 5348 return usage; 5349 } 5350 5351 ASTUnit *astUnit = static_cast<ASTUnit*>(TU->TUData); 5352 llvm::OwningPtr<MemUsageEntries> entries(new MemUsageEntries()); 5353 ASTContext &astContext = astUnit->getASTContext(); 5354 5355 // How much memory is used by AST nodes and types? 5356 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST, 5357 (unsigned long) astContext.getASTAllocatedMemory()); 5358 5359 // How much memory is used by identifiers? 5360 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Identifiers, 5361 (unsigned long) astContext.Idents.getAllocator().getTotalMemory()); 5362 5363 // How much memory is used for selectors? 5364 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Selectors, 5365 (unsigned long) astContext.Selectors.getTotalMemory()); 5366 5367 // How much memory is used by ASTContext's side tables? 5368 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST_SideTables, 5369 (unsigned long) astContext.getSideTableAllocatedMemory()); 5370 5371 // How much memory is used for caching global code completion results? 5372 unsigned long completionBytes = 0; 5373 if (GlobalCodeCompletionAllocator *completionAllocator = 5374 astUnit->getCachedCompletionAllocator().getPtr()) { 5375 completionBytes = completionAllocator->getTotalMemory(); 5376 } 5377 createCXTUResourceUsageEntry(*entries, 5378 CXTUResourceUsage_GlobalCompletionResults, 5379 completionBytes); 5380 5381 // How much memory is being used by SourceManager's content cache? 5382 createCXTUResourceUsageEntry(*entries, 5383 CXTUResourceUsage_SourceManagerContentCache, 5384 (unsigned long) astContext.getSourceManager().getContentCacheSize()); 5385 5386 // How much memory is being used by the MemoryBuffer's in SourceManager? 5387 const SourceManager::MemoryBufferSizes &srcBufs = 5388 astUnit->getSourceManager().getMemoryBufferSizes(); 5389 5390 createCXTUResourceUsageEntry(*entries, 5391 CXTUResourceUsage_SourceManager_Membuffer_Malloc, 5392 (unsigned long) srcBufs.malloc_bytes); 5393 createCXTUResourceUsageEntry(*entries, 5394 CXTUResourceUsage_SourceManager_Membuffer_MMap, 5395 (unsigned long) srcBufs.mmap_bytes); 5396 5397 // How much memory is being used by the ExternalASTSource? 5398 if (ExternalASTSource *esrc = astContext.getExternalSource()) { 5399 const ExternalASTSource::MemoryBufferSizes &sizes = 5400 esrc->getMemoryBufferSizes(); 5401 5402 createCXTUResourceUsageEntry(*entries, 5403 CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc, 5404 (unsigned long) sizes.malloc_bytes); 5405 createCXTUResourceUsageEntry(*entries, 5406 CXTUResourceUsage_ExternalASTSource_Membuffer_MMap, 5407 (unsigned long) sizes.mmap_bytes); 5408 } 5409 5410 // How much memory is being used by the Preprocessor? 5411 Preprocessor &pp = astUnit->getPreprocessor(); 5412 createCXTUResourceUsageEntry(*entries, 5413 CXTUResourceUsage_Preprocessor, 5414 pp.getTotalMemory()); 5415 5416 if (PreprocessingRecord *pRec = pp.getPreprocessingRecord()) { 5417 createCXTUResourceUsageEntry(*entries, 5418 CXTUResourceUsage_PreprocessingRecord, 5419 pRec->getTotalMemory()); 5420 } 5421 5422 5423 CXTUResourceUsage usage = { (void*) entries.get(), 5424 (unsigned) entries->size(), 5425 entries->size() ? &(*entries)[0] : 0 }; 5426 entries.take(); 5427 return usage; 5428} 5429 5430void clang_disposeCXTUResourceUsage(CXTUResourceUsage usage) { 5431 if (usage.data) 5432 delete (MemUsageEntries*) usage.data; 5433} 5434 5435} // end extern "C" 5436 5437void clang::PrintLibclangResourceUsage(CXTranslationUnit TU) { 5438 CXTUResourceUsage Usage = clang_getCXTUResourceUsage(TU); 5439 for (unsigned I = 0; I != Usage.numEntries; ++I) 5440 fprintf(stderr, " %s: %lu\n", 5441 clang_getTUResourceUsageName(Usage.entries[I].kind), 5442 Usage.entries[I].amount); 5443 5444 clang_disposeCXTUResourceUsage(Usage); 5445} 5446 5447//===----------------------------------------------------------------------===// 5448// Misc. utility functions. 5449//===----------------------------------------------------------------------===// 5450 5451/// Default to using an 8 MB stack size on "safety" threads. 5452static unsigned SafetyStackThreadSize = 8 << 20; 5453 5454namespace clang { 5455 5456bool RunSafely(llvm::CrashRecoveryContext &CRC, 5457 void (*Fn)(void*), void *UserData, 5458 unsigned Size) { 5459 if (!Size) 5460 Size = GetSafetyThreadStackSize(); 5461 if (Size) 5462 return CRC.RunSafelyOnThread(Fn, UserData, Size); 5463 return CRC.RunSafely(Fn, UserData); 5464} 5465 5466unsigned GetSafetyThreadStackSize() { 5467 return SafetyStackThreadSize; 5468} 5469 5470void SetSafetyThreadStackSize(unsigned Value) { 5471 SafetyStackThreadSize = Value; 5472} 5473 5474} 5475 5476extern "C" { 5477 5478CXString clang_getClangVersion() { 5479 return createCXString(getClangFullVersion()); 5480} 5481 5482} // end: extern "C" 5483 5484