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