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