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