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