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