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