CXCursor.cpp revision b395c63b473bf1b3783bff371a993332e8c4c5e3
1//===- CXCursor.cpp - Routines for manipulating CXCursors -----------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines routines for manipulating CXCursors. It should be the 11// only file that has internal knowledge of the encoding of the data in 12// CXCursor. 13// 14//===----------------------------------------------------------------------===// 15 16#include "CXTranslationUnit.h" 17#include "CXCursor.h" 18#include "CXString.h" 19#include "clang/Frontend/ASTUnit.h" 20#include "clang/AST/Decl.h" 21#include "clang/AST/DeclCXX.h" 22#include "clang/AST/DeclObjC.h" 23#include "clang/AST/DeclTemplate.h" 24#include "clang/AST/Expr.h" 25#include "clang/AST/ExprCXX.h" 26#include "clang/AST/ExprObjC.h" 27#include "clang-c/Index.h" 28#include "llvm/Support/ErrorHandling.h" 29 30using namespace clang; 31using namespace cxcursor; 32 33CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K) { 34 assert(K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid); 35 CXCursor C = { K, 0, { 0, 0, 0 } }; 36 return C; 37} 38 39static CXCursorKind GetCursorKind(const Attr *A) { 40 assert(A && "Invalid arguments!"); 41 switch (A->getKind()) { 42 default: break; 43 case attr::IBAction: return CXCursor_IBActionAttr; 44 case attr::IBOutlet: return CXCursor_IBOutletAttr; 45 case attr::IBOutletCollection: return CXCursor_IBOutletCollectionAttr; 46 case attr::Final: return CXCursor_CXXFinalAttr; 47 case attr::Override: return CXCursor_CXXOverrideAttr; 48 case attr::Annotate: return CXCursor_AnnotateAttr; 49 } 50 51 return CXCursor_UnexposedAttr; 52} 53 54CXCursor cxcursor::MakeCXCursor(const Attr *A, Decl *Parent, 55 CXTranslationUnit TU) { 56 assert(A && Parent && TU && "Invalid arguments!"); 57 CXCursor C = { GetCursorKind(A), 0, { Parent, (void*)A, TU } }; 58 return C; 59} 60 61CXCursor cxcursor::MakeCXCursor(Decl *D, CXTranslationUnit TU, 62 SourceRange RegionOfInterest, 63 bool FirstInDeclGroup) { 64 assert(D && TU && "Invalid arguments!"); 65 66 CXCursorKind K = getCursorKindForDecl(D); 67 68 if (K == CXCursor_ObjCClassMethodDecl || 69 K == CXCursor_ObjCInstanceMethodDecl) { 70 int SelectorIdIndex = -1; 71 // Check if cursor points to a selector id. 72 if (RegionOfInterest.isValid() && 73 RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) { 74 SmallVector<SourceLocation, 16> SelLocs; 75 cast<ObjCMethodDecl>(D)->getSelectorLocs(SelLocs); 76 SmallVector<SourceLocation, 16>::iterator 77 I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin()); 78 if (I != SelLocs.end()) 79 SelectorIdIndex = I - SelLocs.begin(); 80 } 81 CXCursor C = { K, SelectorIdIndex, 82 { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }}; 83 return C; 84 } 85 86 CXCursor C = { K, 0, { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }}; 87 return C; 88} 89 90CXCursor cxcursor::MakeCXCursor(Stmt *S, Decl *Parent, CXTranslationUnit TU, 91 SourceRange RegionOfInterest) { 92 assert(S && TU && "Invalid arguments!"); 93 CXCursorKind K = CXCursor_NotImplemented; 94 95 switch (S->getStmtClass()) { 96 case Stmt::NoStmtClass: 97 break; 98 99 case Stmt::CaseStmtClass: 100 K = CXCursor_CaseStmt; 101 break; 102 103 case Stmt::DefaultStmtClass: 104 K = CXCursor_DefaultStmt; 105 break; 106 107 case Stmt::IfStmtClass: 108 K = CXCursor_IfStmt; 109 break; 110 111 case Stmt::SwitchStmtClass: 112 K = CXCursor_SwitchStmt; 113 break; 114 115 case Stmt::WhileStmtClass: 116 K = CXCursor_WhileStmt; 117 break; 118 119 case Stmt::DoStmtClass: 120 K = CXCursor_DoStmt; 121 break; 122 123 case Stmt::ForStmtClass: 124 K = CXCursor_ForStmt; 125 break; 126 127 case Stmt::GotoStmtClass: 128 K = CXCursor_GotoStmt; 129 break; 130 131 case Stmt::IndirectGotoStmtClass: 132 K = CXCursor_IndirectGotoStmt; 133 break; 134 135 case Stmt::ContinueStmtClass: 136 K = CXCursor_ContinueStmt; 137 break; 138 139 case Stmt::BreakStmtClass: 140 K = CXCursor_BreakStmt; 141 break; 142 143 case Stmt::ReturnStmtClass: 144 K = CXCursor_ReturnStmt; 145 break; 146 147 case Stmt::AsmStmtClass: 148 K = CXCursor_AsmStmt; 149 break; 150 151 case Stmt::ObjCAtTryStmtClass: 152 K = CXCursor_ObjCAtTryStmt; 153 break; 154 155 case Stmt::ObjCAtCatchStmtClass: 156 K = CXCursor_ObjCAtCatchStmt; 157 break; 158 159 case Stmt::ObjCAtFinallyStmtClass: 160 K = CXCursor_ObjCAtFinallyStmt; 161 break; 162 163 case Stmt::ObjCAtThrowStmtClass: 164 K = CXCursor_ObjCAtThrowStmt; 165 break; 166 167 case Stmt::ObjCAtSynchronizedStmtClass: 168 K = CXCursor_ObjCAtSynchronizedStmt; 169 break; 170 171 case Stmt::ObjCAutoreleasePoolStmtClass: 172 K = CXCursor_ObjCAutoreleasePoolStmt; 173 break; 174 175 case Stmt::ObjCForCollectionStmtClass: 176 K = CXCursor_ObjCForCollectionStmt; 177 break; 178 179 case Stmt::CXXCatchStmtClass: 180 K = CXCursor_CXXCatchStmt; 181 break; 182 183 case Stmt::CXXTryStmtClass: 184 K = CXCursor_CXXTryStmt; 185 break; 186 187 case Stmt::CXXForRangeStmtClass: 188 K = CXCursor_CXXForRangeStmt; 189 break; 190 191 case Stmt::SEHTryStmtClass: 192 K = CXCursor_SEHTryStmt; 193 break; 194 195 case Stmt::SEHExceptStmtClass: 196 K = CXCursor_SEHExceptStmt; 197 break; 198 199 case Stmt::SEHFinallyStmtClass: 200 K = CXCursor_SEHFinallyStmt; 201 break; 202 203 case Stmt::ArrayTypeTraitExprClass: 204 case Stmt::AsTypeExprClass: 205 case Stmt::AtomicExprClass: 206 case Stmt::BinaryConditionalOperatorClass: 207 case Stmt::BinaryTypeTraitExprClass: 208 case Stmt::CXXBindTemporaryExprClass: 209 case Stmt::CXXDefaultArgExprClass: 210 case Stmt::CXXScalarValueInitExprClass: 211 case Stmt::CXXUuidofExprClass: 212 case Stmt::ChooseExprClass: 213 case Stmt::DesignatedInitExprClass: 214 case Stmt::ExprWithCleanupsClass: 215 case Stmt::ExpressionTraitExprClass: 216 case Stmt::ExtVectorElementExprClass: 217 case Stmt::ImplicitCastExprClass: 218 case Stmt::ImplicitValueInitExprClass: 219 case Stmt::MaterializeTemporaryExprClass: 220 case Stmt::ObjCIndirectCopyRestoreExprClass: 221 case Stmt::OffsetOfExprClass: 222 case Stmt::ParenListExprClass: 223 case Stmt::PredefinedExprClass: 224 case Stmt::ShuffleVectorExprClass: 225 case Stmt::UnaryExprOrTypeTraitExprClass: 226 case Stmt::UnaryTypeTraitExprClass: 227 case Stmt::VAArgExprClass: 228 K = CXCursor_UnexposedExpr; 229 break; 230 231 case Stmt::OpaqueValueExprClass: 232 if (Expr *Src = cast<OpaqueValueExpr>(S)->getSourceExpr()) 233 return MakeCXCursor(Src, Parent, TU, RegionOfInterest); 234 K = CXCursor_UnexposedExpr; 235 break; 236 237 case Stmt::PseudoObjectExprClass: 238 return MakeCXCursor(cast<PseudoObjectExpr>(S)->getSyntacticForm(), 239 Parent, TU, RegionOfInterest); 240 241 case Stmt::CompoundStmtClass: 242 K = CXCursor_CompoundStmt; 243 break; 244 245 case Stmt::NullStmtClass: 246 K = CXCursor_NullStmt; 247 break; 248 249 case Stmt::LabelStmtClass: 250 K = CXCursor_LabelStmt; 251 break; 252 253 case Stmt::DeclStmtClass: 254 K = CXCursor_DeclStmt; 255 break; 256 257 case Stmt::IntegerLiteralClass: 258 K = CXCursor_IntegerLiteral; 259 break; 260 261 case Stmt::FloatingLiteralClass: 262 K = CXCursor_FloatingLiteral; 263 break; 264 265 case Stmt::ImaginaryLiteralClass: 266 K = CXCursor_ImaginaryLiteral; 267 break; 268 269 case Stmt::StringLiteralClass: 270 K = CXCursor_StringLiteral; 271 break; 272 273 case Stmt::CharacterLiteralClass: 274 K = CXCursor_CharacterLiteral; 275 break; 276 277 case Stmt::ParenExprClass: 278 K = CXCursor_ParenExpr; 279 break; 280 281 case Stmt::UnaryOperatorClass: 282 K = CXCursor_UnaryOperator; 283 break; 284 285 case Stmt::CXXNoexceptExprClass: 286 K = CXCursor_UnaryExpr; 287 break; 288 289 case Stmt::ArraySubscriptExprClass: 290 K = CXCursor_ArraySubscriptExpr; 291 break; 292 293 case Stmt::BinaryOperatorClass: 294 K = CXCursor_BinaryOperator; 295 break; 296 297 case Stmt::CompoundAssignOperatorClass: 298 K = CXCursor_CompoundAssignOperator; 299 break; 300 301 case Stmt::ConditionalOperatorClass: 302 K = CXCursor_ConditionalOperator; 303 break; 304 305 case Stmt::CStyleCastExprClass: 306 K = CXCursor_CStyleCastExpr; 307 break; 308 309 case Stmt::CompoundLiteralExprClass: 310 K = CXCursor_CompoundLiteralExpr; 311 break; 312 313 case Stmt::InitListExprClass: 314 K = CXCursor_InitListExpr; 315 break; 316 317 case Stmt::AddrLabelExprClass: 318 K = CXCursor_AddrLabelExpr; 319 break; 320 321 case Stmt::StmtExprClass: 322 K = CXCursor_StmtExpr; 323 break; 324 325 case Stmt::GenericSelectionExprClass: 326 K = CXCursor_GenericSelectionExpr; 327 break; 328 329 case Stmt::GNUNullExprClass: 330 K = CXCursor_GNUNullExpr; 331 break; 332 333 case Stmt::CXXStaticCastExprClass: 334 K = CXCursor_CXXStaticCastExpr; 335 break; 336 337 case Stmt::CXXDynamicCastExprClass: 338 K = CXCursor_CXXDynamicCastExpr; 339 break; 340 341 case Stmt::CXXReinterpretCastExprClass: 342 K = CXCursor_CXXReinterpretCastExpr; 343 break; 344 345 case Stmt::CXXConstCastExprClass: 346 K = CXCursor_CXXConstCastExpr; 347 break; 348 349 case Stmt::CXXFunctionalCastExprClass: 350 K = CXCursor_CXXFunctionalCastExpr; 351 break; 352 353 case Stmt::CXXTypeidExprClass: 354 K = CXCursor_CXXTypeidExpr; 355 break; 356 357 case Stmt::CXXBoolLiteralExprClass: 358 K = CXCursor_CXXBoolLiteralExpr; 359 break; 360 361 case Stmt::CXXNullPtrLiteralExprClass: 362 K = CXCursor_CXXNullPtrLiteralExpr; 363 break; 364 365 case Stmt::CXXThisExprClass: 366 K = CXCursor_CXXThisExpr; 367 break; 368 369 case Stmt::CXXThrowExprClass: 370 K = CXCursor_CXXThrowExpr; 371 break; 372 373 case Stmt::CXXNewExprClass: 374 K = CXCursor_CXXNewExpr; 375 break; 376 377 case Stmt::CXXDeleteExprClass: 378 K = CXCursor_CXXDeleteExpr; 379 break; 380 381 case Stmt::ObjCStringLiteralClass: 382 K = CXCursor_ObjCStringLiteral; 383 break; 384 385 case Stmt::ObjCEncodeExprClass: 386 K = CXCursor_ObjCEncodeExpr; 387 break; 388 389 case Stmt::ObjCSelectorExprClass: 390 K = CXCursor_ObjCSelectorExpr; 391 break; 392 393 case Stmt::ObjCProtocolExprClass: 394 K = CXCursor_ObjCProtocolExpr; 395 break; 396 397 case Stmt::ObjCBridgedCastExprClass: 398 K = CXCursor_ObjCBridgedCastExpr; 399 break; 400 401 case Stmt::BlockExprClass: 402 K = CXCursor_BlockExpr; 403 break; 404 405 case Stmt::PackExpansionExprClass: 406 K = CXCursor_PackExpansionExpr; 407 break; 408 409 case Stmt::SizeOfPackExprClass: 410 K = CXCursor_SizeOfPackExpr; 411 break; 412 413 case Stmt::BlockDeclRefExprClass: 414 case Stmt::DeclRefExprClass: 415 case Stmt::DependentScopeDeclRefExprClass: 416 case Stmt::SubstNonTypeTemplateParmExprClass: 417 case Stmt::SubstNonTypeTemplateParmPackExprClass: 418 case Stmt::UnresolvedLookupExprClass: 419 K = CXCursor_DeclRefExpr; 420 break; 421 422 case Stmt::CXXDependentScopeMemberExprClass: 423 case Stmt::CXXPseudoDestructorExprClass: 424 case Stmt::MemberExprClass: 425 case Stmt::ObjCIsaExprClass: 426 case Stmt::ObjCIvarRefExprClass: 427 case Stmt::ObjCPropertyRefExprClass: 428 case Stmt::UnresolvedMemberExprClass: 429 K = CXCursor_MemberRefExpr; 430 break; 431 432 case Stmt::CallExprClass: 433 case Stmt::CXXOperatorCallExprClass: 434 case Stmt::CXXMemberCallExprClass: 435 case Stmt::CUDAKernelCallExprClass: 436 case Stmt::CXXConstructExprClass: 437 case Stmt::CXXTemporaryObjectExprClass: 438 case Stmt::CXXUnresolvedConstructExprClass: 439 K = CXCursor_CallExpr; 440 break; 441 442 case Stmt::ObjCMessageExprClass: { 443 K = CXCursor_ObjCMessageExpr; 444 int SelectorIdIndex = -1; 445 // Check if cursor points to a selector id. 446 if (RegionOfInterest.isValid() && 447 RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) { 448 SmallVector<SourceLocation, 16> SelLocs; 449 cast<ObjCMessageExpr>(S)->getSelectorLocs(SelLocs); 450 SmallVector<SourceLocation, 16>::iterator 451 I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin()); 452 if (I != SelLocs.end()) 453 SelectorIdIndex = I - SelLocs.begin(); 454 } 455 CXCursor C = { K, 0, { Parent, S, TU } }; 456 return getSelectorIdentifierCursor(SelectorIdIndex, C); 457 } 458 459 case Stmt::MSDependentExistsStmtClass: 460 K = CXCursor_UnexposedStmt; 461 break; 462 } 463 464 CXCursor C = { K, 0, { Parent, S, TU } }; 465 return C; 466} 467 468CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super, 469 SourceLocation Loc, 470 CXTranslationUnit TU) { 471 assert(Super && TU && "Invalid arguments!"); 472 void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding()); 473 CXCursor C = { CXCursor_ObjCSuperClassRef, 0, { Super, RawLoc, TU } }; 474 return C; 475} 476 477std::pair<ObjCInterfaceDecl *, SourceLocation> 478cxcursor::getCursorObjCSuperClassRef(CXCursor C) { 479 assert(C.kind == CXCursor_ObjCSuperClassRef); 480 return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]), 481 SourceLocation::getFromRawEncoding( 482 reinterpret_cast<uintptr_t>(C.data[1]))); 483} 484 485CXCursor cxcursor::MakeCursorObjCProtocolRef(const ObjCProtocolDecl *Proto, 486 SourceLocation Loc, 487 CXTranslationUnit TU) { 488 assert(Proto && TU && "Invalid arguments!"); 489 void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding()); 490 CXCursor C = { CXCursor_ObjCProtocolRef, 0, { (void*)Proto, RawLoc, TU } }; 491 return C; 492} 493 494std::pair<ObjCProtocolDecl *, SourceLocation> 495cxcursor::getCursorObjCProtocolRef(CXCursor C) { 496 assert(C.kind == CXCursor_ObjCProtocolRef); 497 return std::make_pair(static_cast<ObjCProtocolDecl *>(C.data[0]), 498 SourceLocation::getFromRawEncoding( 499 reinterpret_cast<uintptr_t>(C.data[1]))); 500} 501 502CXCursor cxcursor::MakeCursorObjCClassRef(const ObjCInterfaceDecl *Class, 503 SourceLocation Loc, 504 CXTranslationUnit TU) { 505 // 'Class' can be null for invalid code. 506 if (!Class) 507 return MakeCXCursorInvalid(CXCursor_InvalidCode); 508 assert(TU && "Invalid arguments!"); 509 void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding()); 510 CXCursor C = { CXCursor_ObjCClassRef, 0, { (void*)Class, RawLoc, TU } }; 511 return C; 512} 513 514std::pair<ObjCInterfaceDecl *, SourceLocation> 515cxcursor::getCursorObjCClassRef(CXCursor C) { 516 assert(C.kind == CXCursor_ObjCClassRef); 517 return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]), 518 SourceLocation::getFromRawEncoding( 519 reinterpret_cast<uintptr_t>(C.data[1]))); 520} 521 522CXCursor cxcursor::MakeCursorTypeRef(const TypeDecl *Type, SourceLocation Loc, 523 CXTranslationUnit TU) { 524 assert(Type && TU && "Invalid arguments!"); 525 void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding()); 526 CXCursor C = { CXCursor_TypeRef, 0, { (void*)Type, RawLoc, TU } }; 527 return C; 528} 529 530std::pair<TypeDecl *, SourceLocation> 531cxcursor::getCursorTypeRef(CXCursor C) { 532 assert(C.kind == CXCursor_TypeRef); 533 return std::make_pair(static_cast<TypeDecl *>(C.data[0]), 534 SourceLocation::getFromRawEncoding( 535 reinterpret_cast<uintptr_t>(C.data[1]))); 536} 537 538CXCursor cxcursor::MakeCursorTemplateRef(const TemplateDecl *Template, 539 SourceLocation Loc, 540 CXTranslationUnit TU) { 541 assert(Template && TU && "Invalid arguments!"); 542 void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding()); 543 CXCursor C = { CXCursor_TemplateRef, 0, { (void*)Template, RawLoc, TU } }; 544 return C; 545} 546 547std::pair<TemplateDecl *, SourceLocation> 548cxcursor::getCursorTemplateRef(CXCursor C) { 549 assert(C.kind == CXCursor_TemplateRef); 550 return std::make_pair(static_cast<TemplateDecl *>(C.data[0]), 551 SourceLocation::getFromRawEncoding( 552 reinterpret_cast<uintptr_t>(C.data[1]))); 553} 554 555CXCursor cxcursor::MakeCursorNamespaceRef(const NamedDecl *NS, 556 SourceLocation Loc, 557 CXTranslationUnit TU) { 558 559 assert(NS && (isa<NamespaceDecl>(NS) || isa<NamespaceAliasDecl>(NS)) && TU && 560 "Invalid arguments!"); 561 void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding()); 562 CXCursor C = { CXCursor_NamespaceRef, 0, { (void*)NS, RawLoc, TU } }; 563 return C; 564} 565 566std::pair<NamedDecl *, SourceLocation> 567cxcursor::getCursorNamespaceRef(CXCursor C) { 568 assert(C.kind == CXCursor_NamespaceRef); 569 return std::make_pair(static_cast<NamedDecl *>(C.data[0]), 570 SourceLocation::getFromRawEncoding( 571 reinterpret_cast<uintptr_t>(C.data[1]))); 572} 573 574CXCursor cxcursor::MakeCursorMemberRef(const FieldDecl *Field, SourceLocation Loc, 575 CXTranslationUnit TU) { 576 577 assert(Field && TU && "Invalid arguments!"); 578 void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding()); 579 CXCursor C = { CXCursor_MemberRef, 0, { (void*)Field, RawLoc, TU } }; 580 return C; 581} 582 583std::pair<FieldDecl *, SourceLocation> 584cxcursor::getCursorMemberRef(CXCursor C) { 585 assert(C.kind == CXCursor_MemberRef); 586 return std::make_pair(static_cast<FieldDecl *>(C.data[0]), 587 SourceLocation::getFromRawEncoding( 588 reinterpret_cast<uintptr_t>(C.data[1]))); 589} 590 591CXCursor cxcursor::MakeCursorCXXBaseSpecifier(CXXBaseSpecifier *B, 592 CXTranslationUnit TU){ 593 CXCursor C = { CXCursor_CXXBaseSpecifier, 0, { B, 0, TU } }; 594 return C; 595} 596 597CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) { 598 assert(C.kind == CXCursor_CXXBaseSpecifier); 599 return static_cast<CXXBaseSpecifier*>(C.data[0]); 600} 601 602CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range, 603 CXTranslationUnit TU) { 604 CXCursor C = { CXCursor_PreprocessingDirective, 0, 605 { reinterpret_cast<void *>(Range.getBegin().getRawEncoding()), 606 reinterpret_cast<void *>(Range.getEnd().getRawEncoding()), 607 TU } 608 }; 609 return C; 610} 611 612SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) { 613 assert(C.kind == CXCursor_PreprocessingDirective); 614 SourceRange Range = SourceRange(SourceLocation::getFromRawEncoding( 615 reinterpret_cast<uintptr_t> (C.data[0])), 616 SourceLocation::getFromRawEncoding( 617 reinterpret_cast<uintptr_t> (C.data[1]))); 618 ASTUnit *TU = getCursorASTUnit(C); 619 return TU->mapRangeFromPreamble(Range); 620} 621 622CXCursor cxcursor::MakeMacroDefinitionCursor(MacroDefinition *MI, 623 CXTranslationUnit TU) { 624 CXCursor C = { CXCursor_MacroDefinition, 0, { MI, 0, TU } }; 625 return C; 626} 627 628MacroDefinition *cxcursor::getCursorMacroDefinition(CXCursor C) { 629 assert(C.kind == CXCursor_MacroDefinition); 630 return static_cast<MacroDefinition *>(C.data[0]); 631} 632 633CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI, 634 CXTranslationUnit TU) { 635 CXCursor C = { CXCursor_MacroExpansion, 0, { MI, 0, TU } }; 636 return C; 637} 638 639MacroExpansion *cxcursor::getCursorMacroExpansion(CXCursor C) { 640 assert(C.kind == CXCursor_MacroExpansion); 641 return static_cast<MacroExpansion *>(C.data[0]); 642} 643 644CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID, 645 CXTranslationUnit TU) { 646 CXCursor C = { CXCursor_InclusionDirective, 0, { ID, 0, TU } }; 647 return C; 648} 649 650InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) { 651 assert(C.kind == CXCursor_InclusionDirective); 652 return static_cast<InclusionDirective *>(C.data[0]); 653} 654 655CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc, 656 CXTranslationUnit TU) { 657 658 assert(Label && TU && "Invalid arguments!"); 659 void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding()); 660 CXCursor C = { CXCursor_LabelRef, 0, { Label, RawLoc, TU } }; 661 return C; 662} 663 664std::pair<LabelStmt*, SourceLocation> 665cxcursor::getCursorLabelRef(CXCursor C) { 666 assert(C.kind == CXCursor_LabelRef); 667 return std::make_pair(static_cast<LabelStmt *>(C.data[0]), 668 SourceLocation::getFromRawEncoding( 669 reinterpret_cast<uintptr_t>(C.data[1]))); 670} 671 672CXCursor cxcursor::MakeCursorOverloadedDeclRef(OverloadExpr *E, 673 CXTranslationUnit TU) { 674 assert(E && TU && "Invalid arguments!"); 675 OverloadedDeclRefStorage Storage(E); 676 void *RawLoc = reinterpret_cast<void *>(E->getNameLoc().getRawEncoding()); 677 CXCursor C = { 678 CXCursor_OverloadedDeclRef, 0, 679 { Storage.getOpaqueValue(), RawLoc, TU } 680 }; 681 return C; 682} 683 684CXCursor cxcursor::MakeCursorOverloadedDeclRef(Decl *D, 685 SourceLocation Loc, 686 CXTranslationUnit TU) { 687 assert(D && TU && "Invalid arguments!"); 688 void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding()); 689 OverloadedDeclRefStorage Storage(D); 690 CXCursor C = { 691 CXCursor_OverloadedDeclRef, 0, 692 { Storage.getOpaqueValue(), RawLoc, TU } 693 }; 694 return C; 695} 696 697CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name, 698 SourceLocation Loc, 699 CXTranslationUnit TU) { 700 assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!"); 701 void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding()); 702 OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate()); 703 CXCursor C = { 704 CXCursor_OverloadedDeclRef, 0, 705 { Storage.getOpaqueValue(), RawLoc, TU } 706 }; 707 return C; 708} 709 710std::pair<cxcursor::OverloadedDeclRefStorage, SourceLocation> 711cxcursor::getCursorOverloadedDeclRef(CXCursor C) { 712 assert(C.kind == CXCursor_OverloadedDeclRef); 713 return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue(C.data[0]), 714 SourceLocation::getFromRawEncoding( 715 reinterpret_cast<uintptr_t>(C.data[1]))); 716} 717 718Decl *cxcursor::getCursorDecl(CXCursor Cursor) { 719 return (Decl *)Cursor.data[0]; 720} 721 722Expr *cxcursor::getCursorExpr(CXCursor Cursor) { 723 return dyn_cast_or_null<Expr>(getCursorStmt(Cursor)); 724} 725 726Stmt *cxcursor::getCursorStmt(CXCursor Cursor) { 727 if (Cursor.kind == CXCursor_ObjCSuperClassRef || 728 Cursor.kind == CXCursor_ObjCProtocolRef || 729 Cursor.kind == CXCursor_ObjCClassRef) 730 return 0; 731 732 return (Stmt *)Cursor.data[1]; 733} 734 735Attr *cxcursor::getCursorAttr(CXCursor Cursor) { 736 return (Attr *)Cursor.data[1]; 737} 738 739Decl *cxcursor::getCursorParentDecl(CXCursor Cursor) { 740 return (Decl *)Cursor.data[0]; 741} 742 743ASTContext &cxcursor::getCursorContext(CXCursor Cursor) { 744 return getCursorASTUnit(Cursor)->getASTContext(); 745} 746 747ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) { 748 return static_cast<ASTUnit *>(static_cast<CXTranslationUnit>(Cursor.data[2]) 749 ->TUData); 750} 751 752CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) { 753 return static_cast<CXTranslationUnit>(Cursor.data[2]); 754} 755 756static void CollectOverriddenMethods(CXTranslationUnit TU, 757 DeclContext *Ctx, 758 ObjCMethodDecl *Method, 759 SmallVectorImpl<CXCursor> &Methods) { 760 if (!Ctx) 761 return; 762 763 // If we have a class or category implementation, jump straight to the 764 // interface. 765 if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(Ctx)) 766 return CollectOverriddenMethods(TU, Impl->getClassInterface(), 767 Method, Methods); 768 769 ObjCContainerDecl *Container = dyn_cast<ObjCContainerDecl>(Ctx); 770 if (!Container) 771 return; 772 773 // Check whether we have a matching method at this level. 774 if (ObjCMethodDecl *Overridden = Container->getMethod(Method->getSelector(), 775 Method->isInstanceMethod())) 776 if (Method != Overridden) { 777 // We found an override at this level; there is no need to look 778 // into other protocols or categories. 779 Methods.push_back(MakeCXCursor(Overridden, TU)); 780 return; 781 } 782 783 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { 784 for (ObjCProtocolDecl::protocol_iterator P = Protocol->protocol_begin(), 785 PEnd = Protocol->protocol_end(); 786 P != PEnd; ++P) 787 CollectOverriddenMethods(TU, *P, Method, Methods); 788 } 789 790 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) { 791 for (ObjCCategoryDecl::protocol_iterator P = Category->protocol_begin(), 792 PEnd = Category->protocol_end(); 793 P != PEnd; ++P) 794 CollectOverriddenMethods(TU, *P, Method, Methods); 795 } 796 797 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) { 798 for (ObjCInterfaceDecl::protocol_iterator P = Interface->protocol_begin(), 799 PEnd = Interface->protocol_end(); 800 P != PEnd; ++P) 801 CollectOverriddenMethods(TU, *P, Method, Methods); 802 803 for (ObjCCategoryDecl *Category = Interface->getCategoryList(); 804 Category; Category = Category->getNextClassCategory()) 805 CollectOverriddenMethods(TU, Category, Method, Methods); 806 807 // We only look into the superclass if we haven't found anything yet. 808 if (Methods.empty()) 809 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) 810 return CollectOverriddenMethods(TU, Super, Method, Methods); 811 } 812} 813 814void cxcursor::getOverriddenCursors(CXCursor cursor, 815 SmallVectorImpl<CXCursor> &overridden) { 816 if (!clang_isDeclaration(cursor.kind)) 817 return; 818 819 Decl *D = getCursorDecl(cursor); 820 if (!D) 821 return; 822 823 // Handle C++ member functions. 824 CXTranslationUnit TU = getCursorTU(cursor); 825 if (CXXMethodDecl *CXXMethod = dyn_cast<CXXMethodDecl>(D)) { 826 for (CXXMethodDecl::method_iterator 827 M = CXXMethod->begin_overridden_methods(), 828 MEnd = CXXMethod->end_overridden_methods(); 829 M != MEnd; ++M) 830 overridden.push_back(MakeCXCursor(const_cast<CXXMethodDecl*>(*M), TU)); 831 return; 832 } 833 834 ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D); 835 if (!Method) 836 return; 837 838 // Handle Objective-C methods. 839 CollectOverriddenMethods(TU, Method->getDeclContext(), Method, overridden); 840} 841 842std::pair<int, SourceLocation> 843cxcursor::getSelectorIdentifierIndexAndLoc(CXCursor cursor) { 844 if (cursor.kind == CXCursor_ObjCMessageExpr) { 845 if (cursor.xdata != -1) 846 return std::make_pair(cursor.xdata, 847 cast<ObjCMessageExpr>(getCursorExpr(cursor)) 848 ->getSelectorLoc(cursor.xdata)); 849 } else if (cursor.kind == CXCursor_ObjCClassMethodDecl || 850 cursor.kind == CXCursor_ObjCInstanceMethodDecl) { 851 if (cursor.xdata != -1) 852 return std::make_pair(cursor.xdata, 853 cast<ObjCMethodDecl>(getCursorDecl(cursor)) 854 ->getSelectorLoc(cursor.xdata)); 855 } 856 857 return std::make_pair(-1, SourceLocation()); 858} 859 860CXCursor cxcursor::getSelectorIdentifierCursor(int SelIdx, CXCursor cursor) { 861 CXCursor newCursor = cursor; 862 863 if (cursor.kind == CXCursor_ObjCMessageExpr) { 864 if (SelIdx == -1 || 865 unsigned(SelIdx) >= cast<ObjCMessageExpr>(getCursorExpr(cursor)) 866 ->getNumSelectorLocs()) 867 newCursor.xdata = -1; 868 else 869 newCursor.xdata = SelIdx; 870 } else if (cursor.kind == CXCursor_ObjCClassMethodDecl || 871 cursor.kind == CXCursor_ObjCInstanceMethodDecl) { 872 if (SelIdx == -1 || 873 unsigned(SelIdx) >= cast<ObjCMethodDecl>(getCursorDecl(cursor)) 874 ->getNumSelectorLocs()) 875 newCursor.xdata = -1; 876 else 877 newCursor.xdata = SelIdx; 878 } 879 880 return newCursor; 881} 882 883CXCursor cxcursor::getTypeRefCursor(CXCursor cursor) { 884 if (cursor.kind != CXCursor_CallExpr) 885 return cursor; 886 887 if (cursor.xdata == 0) 888 return cursor; 889 890 Expr *E = getCursorExpr(cursor); 891 TypeSourceInfo *Type = 0; 892 if (CXXUnresolvedConstructExpr * 893 UnCtor = dyn_cast<CXXUnresolvedConstructExpr>(E)) { 894 Type = UnCtor->getTypeSourceInfo(); 895 } else if (CXXTemporaryObjectExpr *Tmp = dyn_cast<CXXTemporaryObjectExpr>(E)){ 896 Type = Tmp->getTypeSourceInfo(); 897 } 898 899 if (!Type) 900 return cursor; 901 902 CXTranslationUnit TU = getCursorTU(cursor); 903 QualType Ty = Type->getType(); 904 TypeLoc TL = Type->getTypeLoc(); 905 SourceLocation Loc = TL.getBeginLoc(); 906 907 if (const ElaboratedType *ElabT = Ty->getAs<ElaboratedType>()) { 908 Ty = ElabT->getNamedType(); 909 ElaboratedTypeLoc ElabTL = cast<ElaboratedTypeLoc>(TL); 910 Loc = ElabTL.getNamedTypeLoc().getBeginLoc(); 911 } 912 913 if (const TypedefType *Typedef = Ty->getAs<TypedefType>()) 914 return MakeCursorTypeRef(Typedef->getDecl(), Loc, TU); 915 if (const TagType *Tag = Ty->getAs<TagType>()) 916 return MakeCursorTypeRef(Tag->getDecl(), Loc, TU); 917 if (const TemplateTypeParmType *TemplP = Ty->getAs<TemplateTypeParmType>()) 918 return MakeCursorTypeRef(TemplP->getDecl(), Loc, TU); 919 920 return cursor; 921} 922 923bool cxcursor::operator==(CXCursor X, CXCursor Y) { 924 return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] && 925 X.data[2] == Y.data[2]; 926} 927 928// FIXME: Remove once we can model DeclGroups and their appropriate ranges 929// properly in the ASTs. 930bool cxcursor::isFirstInDeclGroup(CXCursor C) { 931 assert(clang_isDeclaration(C.kind)); 932 return ((uintptr_t) (C.data[1])) != 0; 933} 934 935//===----------------------------------------------------------------------===// 936// libclang CXCursor APIs 937//===----------------------------------------------------------------------===// 938 939extern "C" { 940 941int clang_Cursor_isNull(CXCursor cursor) { 942 return clang_equalCursors(cursor, clang_getNullCursor()); 943} 944 945CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) { 946 return getCursorTU(cursor); 947} 948 949} // end: extern "C" 950 951//===----------------------------------------------------------------------===// 952// CXCursorSet. 953//===----------------------------------------------------------------------===// 954 955typedef llvm::DenseMap<CXCursor, unsigned> CXCursorSet_Impl; 956 957static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) { 958 return (CXCursorSet) setImpl; 959} 960static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) { 961 return (CXCursorSet_Impl*) set; 962} 963namespace llvm { 964template<> struct DenseMapInfo<CXCursor> { 965public: 966 static inline CXCursor getEmptyKey() { 967 return MakeCXCursorInvalid(CXCursor_InvalidFile); 968 } 969 static inline CXCursor getTombstoneKey() { 970 return MakeCXCursorInvalid(CXCursor_NoDeclFound); 971 } 972 static inline unsigned getHashValue(const CXCursor &cursor) { 973 return llvm::DenseMapInfo<std::pair<void*,void*> > 974 ::getHashValue(std::make_pair(cursor.data[0], cursor.data[1])); 975 } 976 static inline bool isEqual(const CXCursor &x, const CXCursor &y) { 977 return x.kind == y.kind && 978 x.data[0] == y.data[0] && 979 x.data[1] == y.data[1]; 980 } 981}; 982} 983 984extern "C" { 985CXCursorSet clang_createCXCursorSet() { 986 return packCXCursorSet(new CXCursorSet_Impl()); 987} 988 989void clang_disposeCXCursorSet(CXCursorSet set) { 990 delete unpackCXCursorSet(set); 991} 992 993unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) { 994 CXCursorSet_Impl *setImpl = unpackCXCursorSet(set); 995 if (!setImpl) 996 return 0; 997 return setImpl->find(cursor) == setImpl->end(); 998} 999 1000unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) { 1001 // Do not insert invalid cursors into the set. 1002 if (cursor.kind >= CXCursor_FirstInvalid && 1003 cursor.kind <= CXCursor_LastInvalid) 1004 return 1; 1005 1006 CXCursorSet_Impl *setImpl = unpackCXCursorSet(set); 1007 if (!setImpl) 1008 return 1; 1009 unsigned &entry = (*setImpl)[cursor]; 1010 unsigned flag = entry == 0 ? 1 : 0; 1011 entry = 1; 1012 return flag; 1013} 1014 1015CXCompletionString clang_getCursorCompletionString(CXCursor cursor) { 1016 enum CXCursorKind kind = clang_getCursorKind(cursor); 1017 if (clang_isDeclaration(kind)) { 1018 Decl *decl = getCursorDecl(cursor); 1019 if (isa<NamedDecl>(decl)) { 1020 NamedDecl *namedDecl = (NamedDecl *)decl; 1021 ASTUnit *unit = getCursorASTUnit(cursor); 1022 if (unit->hasSema()) { 1023 Sema &S = unit->getSema(); 1024 CodeCompletionAllocator *Allocator 1025 = unit->getCursorCompletionAllocator().getPtr(); 1026 CodeCompletionResult Result(namedDecl); 1027 CodeCompletionString *String 1028 = Result.CreateCodeCompletionString(S, *Allocator); 1029 return String; 1030 } 1031 } 1032 } 1033 else if (kind == CXCursor_MacroDefinition) { 1034 MacroDefinition *definition = getCursorMacroDefinition(cursor); 1035 const IdentifierInfo *MacroInfo = definition->getName(); 1036 ASTUnit *unit = getCursorASTUnit(cursor); 1037 if (unit->hasSema()) { 1038 Sema &S = unit->getSema(); 1039 CodeCompletionAllocator *Allocator 1040 = unit->getCursorCompletionAllocator().getPtr(); 1041 CodeCompletionResult Result(const_cast<IdentifierInfo *>(MacroInfo)); 1042 CodeCompletionString *String 1043 = Result.CreateCodeCompletionString(S, *Allocator); 1044 return String; 1045 } 1046 } 1047 return NULL; 1048} 1049 1050} // end: extern "C" 1051