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