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