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