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 "CXType.h" 20 #include "clang-c/Index.h" 21 #include "clang/AST/Attr.h" 22 #include "clang/AST/Decl.h" 23 #include "clang/AST/DeclCXX.h" 24 #include "clang/AST/DeclObjC.h" 25 #include "clang/AST/DeclTemplate.h" 26 #include "clang/AST/Expr.h" 27 #include "clang/AST/ExprCXX.h" 28 #include "clang/AST/ExprObjC.h" 29 #include "clang/Frontend/ASTUnit.h" 30 #include "llvm/Support/ErrorHandling.h" 31 32 using namespace clang; 33 using namespace cxcursor; 34 35 CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K, CXTranslationUnit TU) { 36 assert(K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid); 37 CXCursor C = { K, 0, { nullptr, nullptr, TU } }; 38 return C; 39 } 40 41 static CXCursorKind GetCursorKind(const Attr *A) { 42 assert(A && "Invalid arguments!"); 43 switch (A->getKind()) { 44 default: break; 45 case attr::IBAction: return CXCursor_IBActionAttr; 46 case attr::IBOutlet: return CXCursor_IBOutletAttr; 47 case attr::IBOutletCollection: return CXCursor_IBOutletCollectionAttr; 48 case attr::Final: return CXCursor_CXXFinalAttr; 49 case attr::Override: return CXCursor_CXXOverrideAttr; 50 case attr::Annotate: return CXCursor_AnnotateAttr; 51 case attr::AsmLabel: return CXCursor_AsmLabelAttr; 52 case attr::Packed: return CXCursor_PackedAttr; 53 case attr::Pure: return CXCursor_PureAttr; 54 case attr::Const: return CXCursor_ConstAttr; 55 case attr::NoDuplicate: return CXCursor_NoDuplicateAttr; 56 case attr::CUDAConstant: return CXCursor_CUDAConstantAttr; 57 case attr::CUDADevice: return CXCursor_CUDADeviceAttr; 58 case attr::CUDAGlobal: return CXCursor_CUDAGlobalAttr; 59 case attr::CUDAHost: return CXCursor_CUDAHostAttr; 60 case attr::CUDAShared: return CXCursor_CUDASharedAttr; 61 } 62 63 return CXCursor_UnexposedAttr; 64 } 65 66 CXCursor cxcursor::MakeCXCursor(const Attr *A, const Decl *Parent, 67 CXTranslationUnit TU) { 68 assert(A && Parent && TU && "Invalid arguments!"); 69 CXCursor C = { GetCursorKind(A), 0, { Parent, A, TU } }; 70 return C; 71 } 72 73 CXCursor cxcursor::MakeCXCursor(const Decl *D, CXTranslationUnit TU, 74 SourceRange RegionOfInterest, 75 bool FirstInDeclGroup) { 76 assert(D && TU && "Invalid arguments!"); 77 78 CXCursorKind K = getCursorKindForDecl(D); 79 80 if (K == CXCursor_ObjCClassMethodDecl || 81 K == CXCursor_ObjCInstanceMethodDecl) { 82 int SelectorIdIndex = -1; 83 // Check if cursor points to a selector id. 84 if (RegionOfInterest.isValid() && 85 RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) { 86 SmallVector<SourceLocation, 16> SelLocs; 87 cast<ObjCMethodDecl>(D)->getSelectorLocs(SelLocs); 88 SmallVectorImpl<SourceLocation>::iterator 89 I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin()); 90 if (I != SelLocs.end()) 91 SelectorIdIndex = I - SelLocs.begin(); 92 } 93 CXCursor C = { K, SelectorIdIndex, 94 { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }}; 95 return C; 96 } 97 98 CXCursor C = { K, 0, { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }}; 99 return C; 100 } 101 102 CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent, 103 CXTranslationUnit TU, 104 SourceRange RegionOfInterest) { 105 assert(S && TU && "Invalid arguments!"); 106 CXCursorKind K = CXCursor_NotImplemented; 107 108 switch (S->getStmtClass()) { 109 case Stmt::NoStmtClass: 110 break; 111 112 case Stmt::CaseStmtClass: 113 K = CXCursor_CaseStmt; 114 break; 115 116 case Stmt::DefaultStmtClass: 117 K = CXCursor_DefaultStmt; 118 break; 119 120 case Stmt::IfStmtClass: 121 K = CXCursor_IfStmt; 122 break; 123 124 case Stmt::SwitchStmtClass: 125 K = CXCursor_SwitchStmt; 126 break; 127 128 case Stmt::WhileStmtClass: 129 K = CXCursor_WhileStmt; 130 break; 131 132 case Stmt::DoStmtClass: 133 K = CXCursor_DoStmt; 134 break; 135 136 case Stmt::ForStmtClass: 137 K = CXCursor_ForStmt; 138 break; 139 140 case Stmt::GotoStmtClass: 141 K = CXCursor_GotoStmt; 142 break; 143 144 case Stmt::IndirectGotoStmtClass: 145 K = CXCursor_IndirectGotoStmt; 146 break; 147 148 case Stmt::ContinueStmtClass: 149 K = CXCursor_ContinueStmt; 150 break; 151 152 case Stmt::BreakStmtClass: 153 K = CXCursor_BreakStmt; 154 break; 155 156 case Stmt::ReturnStmtClass: 157 K = CXCursor_ReturnStmt; 158 break; 159 160 case Stmt::GCCAsmStmtClass: 161 K = CXCursor_GCCAsmStmt; 162 break; 163 164 case Stmt::MSAsmStmtClass: 165 K = CXCursor_MSAsmStmt; 166 break; 167 168 case Stmt::ObjCAtTryStmtClass: 169 K = CXCursor_ObjCAtTryStmt; 170 break; 171 172 case Stmt::ObjCAtCatchStmtClass: 173 K = CXCursor_ObjCAtCatchStmt; 174 break; 175 176 case Stmt::ObjCAtFinallyStmtClass: 177 K = CXCursor_ObjCAtFinallyStmt; 178 break; 179 180 case Stmt::ObjCAtThrowStmtClass: 181 K = CXCursor_ObjCAtThrowStmt; 182 break; 183 184 case Stmt::ObjCAtSynchronizedStmtClass: 185 K = CXCursor_ObjCAtSynchronizedStmt; 186 break; 187 188 case Stmt::ObjCAutoreleasePoolStmtClass: 189 K = CXCursor_ObjCAutoreleasePoolStmt; 190 break; 191 192 case Stmt::ObjCForCollectionStmtClass: 193 K = CXCursor_ObjCForCollectionStmt; 194 break; 195 196 case Stmt::CXXCatchStmtClass: 197 K = CXCursor_CXXCatchStmt; 198 break; 199 200 case Stmt::CXXTryStmtClass: 201 K = CXCursor_CXXTryStmt; 202 break; 203 204 case Stmt::CXXForRangeStmtClass: 205 K = CXCursor_CXXForRangeStmt; 206 break; 207 208 case Stmt::SEHTryStmtClass: 209 K = CXCursor_SEHTryStmt; 210 break; 211 212 case Stmt::SEHExceptStmtClass: 213 K = CXCursor_SEHExceptStmt; 214 break; 215 216 case Stmt::SEHFinallyStmtClass: 217 K = CXCursor_SEHFinallyStmt; 218 break; 219 220 case Stmt::SEHLeaveStmtClass: 221 K = CXCursor_SEHLeaveStmt; 222 break; 223 224 case Stmt::ArrayTypeTraitExprClass: 225 case Stmt::AsTypeExprClass: 226 case Stmt::AtomicExprClass: 227 case Stmt::BinaryConditionalOperatorClass: 228 case Stmt::TypeTraitExprClass: 229 case Stmt::CXXBindTemporaryExprClass: 230 case Stmt::CXXDefaultArgExprClass: 231 case Stmt::CXXDefaultInitExprClass: 232 case Stmt::CXXFoldExprClass: 233 case Stmt::CXXStdInitializerListExprClass: 234 case Stmt::CXXScalarValueInitExprClass: 235 case Stmt::CXXUuidofExprClass: 236 case Stmt::ChooseExprClass: 237 case Stmt::DesignatedInitExprClass: 238 case Stmt::ExprWithCleanupsClass: 239 case Stmt::ExpressionTraitExprClass: 240 case Stmt::ExtVectorElementExprClass: 241 case Stmt::ImplicitCastExprClass: 242 case Stmt::ImplicitValueInitExprClass: 243 case Stmt::MaterializeTemporaryExprClass: 244 case Stmt::ObjCIndirectCopyRestoreExprClass: 245 case Stmt::OffsetOfExprClass: 246 case Stmt::ParenListExprClass: 247 case Stmt::PredefinedExprClass: 248 case Stmt::ShuffleVectorExprClass: 249 case Stmt::ConvertVectorExprClass: 250 case Stmt::UnaryExprOrTypeTraitExprClass: 251 case Stmt::VAArgExprClass: 252 case Stmt::ObjCArrayLiteralClass: 253 case Stmt::ObjCDictionaryLiteralClass: 254 case Stmt::ObjCBoxedExprClass: 255 case Stmt::ObjCSubscriptRefExprClass: 256 K = CXCursor_UnexposedExpr; 257 break; 258 259 case Stmt::OpaqueValueExprClass: 260 if (Expr *Src = cast<OpaqueValueExpr>(S)->getSourceExpr()) 261 return MakeCXCursor(Src, Parent, TU, RegionOfInterest); 262 K = CXCursor_UnexposedExpr; 263 break; 264 265 case Stmt::PseudoObjectExprClass: 266 return MakeCXCursor(cast<PseudoObjectExpr>(S)->getSyntacticForm(), 267 Parent, TU, RegionOfInterest); 268 269 case Stmt::CompoundStmtClass: 270 K = CXCursor_CompoundStmt; 271 break; 272 273 case Stmt::NullStmtClass: 274 K = CXCursor_NullStmt; 275 break; 276 277 case Stmt::LabelStmtClass: 278 K = CXCursor_LabelStmt; 279 break; 280 281 case Stmt::AttributedStmtClass: 282 K = CXCursor_UnexposedStmt; 283 break; 284 285 case Stmt::DeclStmtClass: 286 K = CXCursor_DeclStmt; 287 break; 288 289 case Stmt::CapturedStmtClass: 290 K = CXCursor_UnexposedStmt; 291 break; 292 293 case Stmt::IntegerLiteralClass: 294 K = CXCursor_IntegerLiteral; 295 break; 296 297 case Stmt::FloatingLiteralClass: 298 K = CXCursor_FloatingLiteral; 299 break; 300 301 case Stmt::ImaginaryLiteralClass: 302 K = CXCursor_ImaginaryLiteral; 303 break; 304 305 case Stmt::StringLiteralClass: 306 K = CXCursor_StringLiteral; 307 break; 308 309 case Stmt::CharacterLiteralClass: 310 K = CXCursor_CharacterLiteral; 311 break; 312 313 case Stmt::ParenExprClass: 314 K = CXCursor_ParenExpr; 315 break; 316 317 case Stmt::UnaryOperatorClass: 318 K = CXCursor_UnaryOperator; 319 break; 320 321 case Stmt::CXXNoexceptExprClass: 322 K = CXCursor_UnaryExpr; 323 break; 324 325 case Stmt::ArraySubscriptExprClass: 326 K = CXCursor_ArraySubscriptExpr; 327 break; 328 329 case Stmt::BinaryOperatorClass: 330 K = CXCursor_BinaryOperator; 331 break; 332 333 case Stmt::CompoundAssignOperatorClass: 334 K = CXCursor_CompoundAssignOperator; 335 break; 336 337 case Stmt::ConditionalOperatorClass: 338 K = CXCursor_ConditionalOperator; 339 break; 340 341 case Stmt::CStyleCastExprClass: 342 K = CXCursor_CStyleCastExpr; 343 break; 344 345 case Stmt::CompoundLiteralExprClass: 346 K = CXCursor_CompoundLiteralExpr; 347 break; 348 349 case Stmt::InitListExprClass: 350 K = CXCursor_InitListExpr; 351 break; 352 353 case Stmt::AddrLabelExprClass: 354 K = CXCursor_AddrLabelExpr; 355 break; 356 357 case Stmt::StmtExprClass: 358 K = CXCursor_StmtExpr; 359 break; 360 361 case Stmt::GenericSelectionExprClass: 362 K = CXCursor_GenericSelectionExpr; 363 break; 364 365 case Stmt::GNUNullExprClass: 366 K = CXCursor_GNUNullExpr; 367 break; 368 369 case Stmt::CXXStaticCastExprClass: 370 K = CXCursor_CXXStaticCastExpr; 371 break; 372 373 case Stmt::CXXDynamicCastExprClass: 374 K = CXCursor_CXXDynamicCastExpr; 375 break; 376 377 case Stmt::CXXReinterpretCastExprClass: 378 K = CXCursor_CXXReinterpretCastExpr; 379 break; 380 381 case Stmt::CXXConstCastExprClass: 382 K = CXCursor_CXXConstCastExpr; 383 break; 384 385 case Stmt::CXXFunctionalCastExprClass: 386 K = CXCursor_CXXFunctionalCastExpr; 387 break; 388 389 case Stmt::CXXTypeidExprClass: 390 K = CXCursor_CXXTypeidExpr; 391 break; 392 393 case Stmt::CXXBoolLiteralExprClass: 394 K = CXCursor_CXXBoolLiteralExpr; 395 break; 396 397 case Stmt::CXXNullPtrLiteralExprClass: 398 K = CXCursor_CXXNullPtrLiteralExpr; 399 break; 400 401 case Stmt::CXXThisExprClass: 402 K = CXCursor_CXXThisExpr; 403 break; 404 405 case Stmt::CXXThrowExprClass: 406 K = CXCursor_CXXThrowExpr; 407 break; 408 409 case Stmt::CXXNewExprClass: 410 K = CXCursor_CXXNewExpr; 411 break; 412 413 case Stmt::CXXDeleteExprClass: 414 K = CXCursor_CXXDeleteExpr; 415 break; 416 417 case Stmt::ObjCStringLiteralClass: 418 K = CXCursor_ObjCStringLiteral; 419 break; 420 421 case Stmt::ObjCEncodeExprClass: 422 K = CXCursor_ObjCEncodeExpr; 423 break; 424 425 case Stmt::ObjCSelectorExprClass: 426 K = CXCursor_ObjCSelectorExpr; 427 break; 428 429 case Stmt::ObjCProtocolExprClass: 430 K = CXCursor_ObjCProtocolExpr; 431 break; 432 433 case Stmt::ObjCBoolLiteralExprClass: 434 K = CXCursor_ObjCBoolLiteralExpr; 435 break; 436 437 case Stmt::ObjCBridgedCastExprClass: 438 K = CXCursor_ObjCBridgedCastExpr; 439 break; 440 441 case Stmt::BlockExprClass: 442 K = CXCursor_BlockExpr; 443 break; 444 445 case Stmt::PackExpansionExprClass: 446 K = CXCursor_PackExpansionExpr; 447 break; 448 449 case Stmt::SizeOfPackExprClass: 450 K = CXCursor_SizeOfPackExpr; 451 break; 452 453 case Stmt::DeclRefExprClass: 454 if (const ImplicitParamDecl *IPD = 455 dyn_cast_or_null<ImplicitParamDecl>(cast<DeclRefExpr>(S)->getDecl())) { 456 if (const ObjCMethodDecl *MD = 457 dyn_cast<ObjCMethodDecl>(IPD->getDeclContext())) { 458 if (MD->getSelfDecl() == IPD) { 459 K = CXCursor_ObjCSelfExpr; 460 break; 461 } 462 } 463 } 464 465 K = CXCursor_DeclRefExpr; 466 break; 467 468 case Stmt::DependentScopeDeclRefExprClass: 469 case Stmt::SubstNonTypeTemplateParmExprClass: 470 case Stmt::SubstNonTypeTemplateParmPackExprClass: 471 case Stmt::FunctionParmPackExprClass: 472 case Stmt::UnresolvedLookupExprClass: 473 case Stmt::TypoExprClass: // A typo could actually be a DeclRef or a MemberRef 474 K = CXCursor_DeclRefExpr; 475 break; 476 477 case Stmt::CXXDependentScopeMemberExprClass: 478 case Stmt::CXXPseudoDestructorExprClass: 479 case Stmt::MemberExprClass: 480 case Stmt::MSPropertyRefExprClass: 481 case Stmt::ObjCIsaExprClass: 482 case Stmt::ObjCIvarRefExprClass: 483 case Stmt::ObjCPropertyRefExprClass: 484 case Stmt::UnresolvedMemberExprClass: 485 K = CXCursor_MemberRefExpr; 486 break; 487 488 case Stmt::CallExprClass: 489 case Stmt::CXXOperatorCallExprClass: 490 case Stmt::CXXMemberCallExprClass: 491 case Stmt::CUDAKernelCallExprClass: 492 case Stmt::CXXConstructExprClass: 493 case Stmt::CXXTemporaryObjectExprClass: 494 case Stmt::CXXUnresolvedConstructExprClass: 495 case Stmt::UserDefinedLiteralClass: 496 K = CXCursor_CallExpr; 497 break; 498 499 case Stmt::LambdaExprClass: 500 K = CXCursor_LambdaExpr; 501 break; 502 503 case Stmt::ObjCMessageExprClass: { 504 K = CXCursor_ObjCMessageExpr; 505 int SelectorIdIndex = -1; 506 // Check if cursor points to a selector id. 507 if (RegionOfInterest.isValid() && 508 RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) { 509 SmallVector<SourceLocation, 16> SelLocs; 510 cast<ObjCMessageExpr>(S)->getSelectorLocs(SelLocs); 511 SmallVectorImpl<SourceLocation>::iterator 512 I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin()); 513 if (I != SelLocs.end()) 514 SelectorIdIndex = I - SelLocs.begin(); 515 } 516 CXCursor C = { K, 0, { Parent, S, TU } }; 517 return getSelectorIdentifierCursor(SelectorIdIndex, C); 518 } 519 520 case Stmt::MSDependentExistsStmtClass: 521 K = CXCursor_UnexposedStmt; 522 break; 523 case Stmt::OMPParallelDirectiveClass: 524 K = CXCursor_OMPParallelDirective; 525 break; 526 case Stmt::OMPSimdDirectiveClass: 527 K = CXCursor_OMPSimdDirective; 528 break; 529 case Stmt::OMPForDirectiveClass: 530 K = CXCursor_OMPForDirective; 531 break; 532 case Stmt::OMPForSimdDirectiveClass: 533 K = CXCursor_OMPForSimdDirective; 534 break; 535 case Stmt::OMPSectionsDirectiveClass: 536 K = CXCursor_OMPSectionsDirective; 537 break; 538 case Stmt::OMPSectionDirectiveClass: 539 K = CXCursor_OMPSectionDirective; 540 break; 541 case Stmt::OMPSingleDirectiveClass: 542 K = CXCursor_OMPSingleDirective; 543 break; 544 case Stmt::OMPMasterDirectiveClass: 545 K = CXCursor_OMPMasterDirective; 546 break; 547 case Stmt::OMPCriticalDirectiveClass: 548 K = CXCursor_OMPCriticalDirective; 549 break; 550 case Stmt::OMPParallelForDirectiveClass: 551 K = CXCursor_OMPParallelForDirective; 552 break; 553 case Stmt::OMPParallelForSimdDirectiveClass: 554 K = CXCursor_OMPParallelForSimdDirective; 555 break; 556 case Stmt::OMPParallelSectionsDirectiveClass: 557 K = CXCursor_OMPParallelSectionsDirective; 558 break; 559 case Stmt::OMPTaskDirectiveClass: 560 K = CXCursor_OMPTaskDirective; 561 break; 562 case Stmt::OMPTaskyieldDirectiveClass: 563 K = CXCursor_OMPTaskyieldDirective; 564 break; 565 case Stmt::OMPBarrierDirectiveClass: 566 K = CXCursor_OMPBarrierDirective; 567 break; 568 case Stmt::OMPTaskwaitDirectiveClass: 569 K = CXCursor_OMPTaskwaitDirective; 570 break; 571 case Stmt::OMPFlushDirectiveClass: 572 K = CXCursor_OMPFlushDirective; 573 break; 574 case Stmt::OMPOrderedDirectiveClass: 575 K = CXCursor_OMPOrderedDirective; 576 break; 577 case Stmt::OMPAtomicDirectiveClass: 578 K = CXCursor_OMPAtomicDirective; 579 break; 580 case Stmt::OMPTargetDirectiveClass: 581 K = CXCursor_OMPTargetDirective; 582 break; 583 case Stmt::OMPTeamsDirectiveClass: 584 K = CXCursor_OMPTeamsDirective; 585 break; 586 } 587 588 CXCursor C = { K, 0, { Parent, S, TU } }; 589 return C; 590 } 591 592 CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super, 593 SourceLocation Loc, 594 CXTranslationUnit TU) { 595 assert(Super && TU && "Invalid arguments!"); 596 void *RawLoc = Loc.getPtrEncoding(); 597 CXCursor C = { CXCursor_ObjCSuperClassRef, 0, { Super, RawLoc, TU } }; 598 return C; 599 } 600 601 std::pair<const ObjCInterfaceDecl *, SourceLocation> 602 cxcursor::getCursorObjCSuperClassRef(CXCursor C) { 603 assert(C.kind == CXCursor_ObjCSuperClassRef); 604 return std::make_pair(static_cast<const ObjCInterfaceDecl *>(C.data[0]), 605 SourceLocation::getFromPtrEncoding(C.data[1])); 606 } 607 608 CXCursor cxcursor::MakeCursorObjCProtocolRef(const ObjCProtocolDecl *Proto, 609 SourceLocation Loc, 610 CXTranslationUnit TU) { 611 assert(Proto && TU && "Invalid arguments!"); 612 void *RawLoc = Loc.getPtrEncoding(); 613 CXCursor C = { CXCursor_ObjCProtocolRef, 0, { Proto, RawLoc, TU } }; 614 return C; 615 } 616 617 std::pair<const ObjCProtocolDecl *, SourceLocation> 618 cxcursor::getCursorObjCProtocolRef(CXCursor C) { 619 assert(C.kind == CXCursor_ObjCProtocolRef); 620 return std::make_pair(static_cast<const ObjCProtocolDecl *>(C.data[0]), 621 SourceLocation::getFromPtrEncoding(C.data[1])); 622 } 623 624 CXCursor cxcursor::MakeCursorObjCClassRef(const ObjCInterfaceDecl *Class, 625 SourceLocation Loc, 626 CXTranslationUnit TU) { 627 // 'Class' can be null for invalid code. 628 if (!Class) 629 return MakeCXCursorInvalid(CXCursor_InvalidCode); 630 assert(TU && "Invalid arguments!"); 631 void *RawLoc = Loc.getPtrEncoding(); 632 CXCursor C = { CXCursor_ObjCClassRef, 0, { Class, RawLoc, TU } }; 633 return C; 634 } 635 636 std::pair<const ObjCInterfaceDecl *, SourceLocation> 637 cxcursor::getCursorObjCClassRef(CXCursor C) { 638 assert(C.kind == CXCursor_ObjCClassRef); 639 return std::make_pair(static_cast<const ObjCInterfaceDecl *>(C.data[0]), 640 SourceLocation::getFromPtrEncoding(C.data[1])); 641 } 642 643 CXCursor cxcursor::MakeCursorTypeRef(const TypeDecl *Type, SourceLocation Loc, 644 CXTranslationUnit TU) { 645 assert(Type && TU && "Invalid arguments!"); 646 void *RawLoc = Loc.getPtrEncoding(); 647 CXCursor C = { CXCursor_TypeRef, 0, { Type, RawLoc, TU } }; 648 return C; 649 } 650 651 std::pair<const TypeDecl *, SourceLocation> 652 cxcursor::getCursorTypeRef(CXCursor C) { 653 assert(C.kind == CXCursor_TypeRef); 654 return std::make_pair(static_cast<const TypeDecl *>(C.data[0]), 655 SourceLocation::getFromPtrEncoding(C.data[1])); 656 } 657 658 CXCursor cxcursor::MakeCursorTemplateRef(const TemplateDecl *Template, 659 SourceLocation Loc, 660 CXTranslationUnit TU) { 661 assert(Template && TU && "Invalid arguments!"); 662 void *RawLoc = Loc.getPtrEncoding(); 663 CXCursor C = { CXCursor_TemplateRef, 0, { Template, RawLoc, TU } }; 664 return C; 665 } 666 667 std::pair<const TemplateDecl *, SourceLocation> 668 cxcursor::getCursorTemplateRef(CXCursor C) { 669 assert(C.kind == CXCursor_TemplateRef); 670 return std::make_pair(static_cast<const TemplateDecl *>(C.data[0]), 671 SourceLocation::getFromPtrEncoding(C.data[1])); 672 } 673 674 CXCursor cxcursor::MakeCursorNamespaceRef(const NamedDecl *NS, 675 SourceLocation Loc, 676 CXTranslationUnit TU) { 677 678 assert(NS && (isa<NamespaceDecl>(NS) || isa<NamespaceAliasDecl>(NS)) && TU && 679 "Invalid arguments!"); 680 void *RawLoc = Loc.getPtrEncoding(); 681 CXCursor C = { CXCursor_NamespaceRef, 0, { NS, RawLoc, TU } }; 682 return C; 683 } 684 685 std::pair<const NamedDecl *, SourceLocation> 686 cxcursor::getCursorNamespaceRef(CXCursor C) { 687 assert(C.kind == CXCursor_NamespaceRef); 688 return std::make_pair(static_cast<const NamedDecl *>(C.data[0]), 689 SourceLocation::getFromPtrEncoding(C.data[1])); 690 } 691 692 CXCursor cxcursor::MakeCursorVariableRef(const VarDecl *Var, SourceLocation Loc, 693 CXTranslationUnit TU) { 694 695 assert(Var && TU && "Invalid arguments!"); 696 void *RawLoc = Loc.getPtrEncoding(); 697 CXCursor C = { CXCursor_VariableRef, 0, { Var, RawLoc, TU } }; 698 return C; 699 } 700 701 std::pair<const VarDecl *, SourceLocation> 702 cxcursor::getCursorVariableRef(CXCursor C) { 703 assert(C.kind == CXCursor_VariableRef); 704 return std::make_pair(static_cast<const VarDecl *>(C.data[0]), 705 SourceLocation::getFromPtrEncoding(C.data[1])); 706 } 707 708 CXCursor cxcursor::MakeCursorMemberRef(const FieldDecl *Field, SourceLocation Loc, 709 CXTranslationUnit TU) { 710 711 assert(Field && TU && "Invalid arguments!"); 712 void *RawLoc = Loc.getPtrEncoding(); 713 CXCursor C = { CXCursor_MemberRef, 0, { Field, RawLoc, TU } }; 714 return C; 715 } 716 717 std::pair<const FieldDecl *, SourceLocation> 718 cxcursor::getCursorMemberRef(CXCursor C) { 719 assert(C.kind == CXCursor_MemberRef); 720 return std::make_pair(static_cast<const FieldDecl *>(C.data[0]), 721 SourceLocation::getFromPtrEncoding(C.data[1])); 722 } 723 724 CXCursor cxcursor::MakeCursorCXXBaseSpecifier(const CXXBaseSpecifier *B, 725 CXTranslationUnit TU){ 726 CXCursor C = { CXCursor_CXXBaseSpecifier, 0, { B, nullptr, TU } }; 727 return C; 728 } 729 730 const CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) { 731 assert(C.kind == CXCursor_CXXBaseSpecifier); 732 return static_cast<const CXXBaseSpecifier*>(C.data[0]); 733 } 734 735 CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range, 736 CXTranslationUnit TU) { 737 CXCursor C = { CXCursor_PreprocessingDirective, 0, 738 { Range.getBegin().getPtrEncoding(), 739 Range.getEnd().getPtrEncoding(), 740 TU } 741 }; 742 return C; 743 } 744 745 SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) { 746 assert(C.kind == CXCursor_PreprocessingDirective); 747 SourceRange Range(SourceLocation::getFromPtrEncoding(C.data[0]), 748 SourceLocation::getFromPtrEncoding(C.data[1])); 749 ASTUnit *TU = getCursorASTUnit(C); 750 return TU->mapRangeFromPreamble(Range); 751 } 752 753 CXCursor cxcursor::MakeMacroDefinitionCursor(const MacroDefinitionRecord *MI, 754 CXTranslationUnit TU) { 755 CXCursor C = {CXCursor_MacroDefinition, 0, {MI, nullptr, TU}}; 756 return C; 757 } 758 759 const MacroDefinitionRecord *cxcursor::getCursorMacroDefinition(CXCursor C) { 760 assert(C.kind == CXCursor_MacroDefinition); 761 return static_cast<const MacroDefinitionRecord *>(C.data[0]); 762 } 763 764 CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI, 765 CXTranslationUnit TU) { 766 CXCursor C = { CXCursor_MacroExpansion, 0, { MI, nullptr, TU } }; 767 return C; 768 } 769 770 CXCursor cxcursor::MakeMacroExpansionCursor(MacroDefinitionRecord *MI, 771 SourceLocation Loc, 772 CXTranslationUnit TU) { 773 assert(Loc.isValid()); 774 CXCursor C = {CXCursor_MacroExpansion, 0, {MI, Loc.getPtrEncoding(), TU}}; 775 return C; 776 } 777 778 const IdentifierInfo *cxcursor::MacroExpansionCursor::getName() const { 779 if (isPseudo()) 780 return getAsMacroDefinition()->getName(); 781 return getAsMacroExpansion()->getName(); 782 } 783 const MacroDefinitionRecord * 784 cxcursor::MacroExpansionCursor::getDefinition() const { 785 if (isPseudo()) 786 return getAsMacroDefinition(); 787 return getAsMacroExpansion()->getDefinition(); 788 } 789 SourceRange cxcursor::MacroExpansionCursor::getSourceRange() const { 790 if (isPseudo()) 791 return getPseudoLoc(); 792 return getAsMacroExpansion()->getSourceRange(); 793 } 794 795 CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID, 796 CXTranslationUnit TU) { 797 CXCursor C = { CXCursor_InclusionDirective, 0, { ID, nullptr, TU } }; 798 return C; 799 } 800 801 const InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) { 802 assert(C.kind == CXCursor_InclusionDirective); 803 return static_cast<const InclusionDirective *>(C.data[0]); 804 } 805 806 CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc, 807 CXTranslationUnit TU) { 808 809 assert(Label && TU && "Invalid arguments!"); 810 void *RawLoc = Loc.getPtrEncoding(); 811 CXCursor C = { CXCursor_LabelRef, 0, { Label, RawLoc, TU } }; 812 return C; 813 } 814 815 std::pair<const LabelStmt *, SourceLocation> 816 cxcursor::getCursorLabelRef(CXCursor C) { 817 assert(C.kind == CXCursor_LabelRef); 818 return std::make_pair(static_cast<const LabelStmt *>(C.data[0]), 819 SourceLocation::getFromPtrEncoding(C.data[1])); 820 } 821 822 CXCursor cxcursor::MakeCursorOverloadedDeclRef(const OverloadExpr *E, 823 CXTranslationUnit TU) { 824 assert(E && TU && "Invalid arguments!"); 825 OverloadedDeclRefStorage Storage(E); 826 void *RawLoc = E->getNameLoc().getPtrEncoding(); 827 CXCursor C = { 828 CXCursor_OverloadedDeclRef, 0, 829 { Storage.getOpaqueValue(), RawLoc, TU } 830 }; 831 return C; 832 } 833 834 CXCursor cxcursor::MakeCursorOverloadedDeclRef(const Decl *D, 835 SourceLocation Loc, 836 CXTranslationUnit TU) { 837 assert(D && TU && "Invalid arguments!"); 838 void *RawLoc = Loc.getPtrEncoding(); 839 OverloadedDeclRefStorage Storage(D); 840 CXCursor C = { 841 CXCursor_OverloadedDeclRef, 0, 842 { Storage.getOpaqueValue(), RawLoc, TU } 843 }; 844 return C; 845 } 846 847 CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name, 848 SourceLocation Loc, 849 CXTranslationUnit TU) { 850 assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!"); 851 void *RawLoc = Loc.getPtrEncoding(); 852 OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate()); 853 CXCursor C = { 854 CXCursor_OverloadedDeclRef, 0, 855 { Storage.getOpaqueValue(), RawLoc, TU } 856 }; 857 return C; 858 } 859 860 std::pair<cxcursor::OverloadedDeclRefStorage, SourceLocation> 861 cxcursor::getCursorOverloadedDeclRef(CXCursor C) { 862 assert(C.kind == CXCursor_OverloadedDeclRef); 863 return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue( 864 const_cast<void *>(C.data[0])), 865 SourceLocation::getFromPtrEncoding(C.data[1])); 866 } 867 868 const Decl *cxcursor::getCursorDecl(CXCursor Cursor) { 869 return static_cast<const Decl *>(Cursor.data[0]); 870 } 871 872 const Expr *cxcursor::getCursorExpr(CXCursor Cursor) { 873 return dyn_cast_or_null<Expr>(getCursorStmt(Cursor)); 874 } 875 876 const Stmt *cxcursor::getCursorStmt(CXCursor Cursor) { 877 if (Cursor.kind == CXCursor_ObjCSuperClassRef || 878 Cursor.kind == CXCursor_ObjCProtocolRef || 879 Cursor.kind == CXCursor_ObjCClassRef) 880 return nullptr; 881 882 return static_cast<const Stmt *>(Cursor.data[1]); 883 } 884 885 const Attr *cxcursor::getCursorAttr(CXCursor Cursor) { 886 return static_cast<const Attr *>(Cursor.data[1]); 887 } 888 889 const Decl *cxcursor::getCursorParentDecl(CXCursor Cursor) { 890 return static_cast<const Decl *>(Cursor.data[0]); 891 } 892 893 ASTContext &cxcursor::getCursorContext(CXCursor Cursor) { 894 return getCursorASTUnit(Cursor)->getASTContext(); 895 } 896 897 ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) { 898 CXTranslationUnit TU = getCursorTU(Cursor); 899 if (!TU) 900 return nullptr; 901 return cxtu::getASTUnit(TU); 902 } 903 904 CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) { 905 return static_cast<CXTranslationUnit>(const_cast<void*>(Cursor.data[2])); 906 } 907 908 void cxcursor::getOverriddenCursors(CXCursor cursor, 909 SmallVectorImpl<CXCursor> &overridden) { 910 assert(clang_isDeclaration(cursor.kind)); 911 const NamedDecl *D = dyn_cast_or_null<NamedDecl>(getCursorDecl(cursor)); 912 if (!D) 913 return; 914 915 CXTranslationUnit TU = getCursorTU(cursor); 916 SmallVector<const NamedDecl *, 8> OverDecls; 917 D->getASTContext().getOverriddenMethods(D, OverDecls); 918 919 for (SmallVectorImpl<const NamedDecl *>::iterator 920 I = OverDecls.begin(), E = OverDecls.end(); I != E; ++I) { 921 overridden.push_back(MakeCXCursor(*I, TU)); 922 } 923 } 924 925 std::pair<int, SourceLocation> 926 cxcursor::getSelectorIdentifierIndexAndLoc(CXCursor cursor) { 927 if (cursor.kind == CXCursor_ObjCMessageExpr) { 928 if (cursor.xdata != -1) 929 return std::make_pair(cursor.xdata, 930 cast<ObjCMessageExpr>(getCursorExpr(cursor)) 931 ->getSelectorLoc(cursor.xdata)); 932 } else if (cursor.kind == CXCursor_ObjCClassMethodDecl || 933 cursor.kind == CXCursor_ObjCInstanceMethodDecl) { 934 if (cursor.xdata != -1) 935 return std::make_pair(cursor.xdata, 936 cast<ObjCMethodDecl>(getCursorDecl(cursor)) 937 ->getSelectorLoc(cursor.xdata)); 938 } 939 940 return std::make_pair(-1, SourceLocation()); 941 } 942 943 CXCursor cxcursor::getSelectorIdentifierCursor(int SelIdx, CXCursor cursor) { 944 CXCursor newCursor = cursor; 945 946 if (cursor.kind == CXCursor_ObjCMessageExpr) { 947 if (SelIdx == -1 || 948 unsigned(SelIdx) >= cast<ObjCMessageExpr>(getCursorExpr(cursor)) 949 ->getNumSelectorLocs()) 950 newCursor.xdata = -1; 951 else 952 newCursor.xdata = SelIdx; 953 } else if (cursor.kind == CXCursor_ObjCClassMethodDecl || 954 cursor.kind == CXCursor_ObjCInstanceMethodDecl) { 955 if (SelIdx == -1 || 956 unsigned(SelIdx) >= cast<ObjCMethodDecl>(getCursorDecl(cursor)) 957 ->getNumSelectorLocs()) 958 newCursor.xdata = -1; 959 else 960 newCursor.xdata = SelIdx; 961 } 962 963 return newCursor; 964 } 965 966 CXCursor cxcursor::getTypeRefCursor(CXCursor cursor) { 967 if (cursor.kind != CXCursor_CallExpr) 968 return cursor; 969 970 if (cursor.xdata == 0) 971 return cursor; 972 973 const Expr *E = getCursorExpr(cursor); 974 TypeSourceInfo *Type = nullptr; 975 if (const CXXUnresolvedConstructExpr * 976 UnCtor = dyn_cast<CXXUnresolvedConstructExpr>(E)) { 977 Type = UnCtor->getTypeSourceInfo(); 978 } else if (const CXXTemporaryObjectExpr *Tmp = 979 dyn_cast<CXXTemporaryObjectExpr>(E)){ 980 Type = Tmp->getTypeSourceInfo(); 981 } 982 983 if (!Type) 984 return cursor; 985 986 CXTranslationUnit TU = getCursorTU(cursor); 987 QualType Ty = Type->getType(); 988 TypeLoc TL = Type->getTypeLoc(); 989 SourceLocation Loc = TL.getBeginLoc(); 990 991 if (const ElaboratedType *ElabT = Ty->getAs<ElaboratedType>()) { 992 Ty = ElabT->getNamedType(); 993 ElaboratedTypeLoc ElabTL = TL.castAs<ElaboratedTypeLoc>(); 994 Loc = ElabTL.getNamedTypeLoc().getBeginLoc(); 995 } 996 997 if (const TypedefType *Typedef = Ty->getAs<TypedefType>()) 998 return MakeCursorTypeRef(Typedef->getDecl(), Loc, TU); 999 if (const TagType *Tag = Ty->getAs<TagType>()) 1000 return MakeCursorTypeRef(Tag->getDecl(), Loc, TU); 1001 if (const TemplateTypeParmType *TemplP = Ty->getAs<TemplateTypeParmType>()) 1002 return MakeCursorTypeRef(TemplP->getDecl(), Loc, TU); 1003 1004 return cursor; 1005 } 1006 1007 bool cxcursor::operator==(CXCursor X, CXCursor Y) { 1008 return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] && 1009 X.data[2] == Y.data[2]; 1010 } 1011 1012 // FIXME: Remove once we can model DeclGroups and their appropriate ranges 1013 // properly in the ASTs. 1014 bool cxcursor::isFirstInDeclGroup(CXCursor C) { 1015 assert(clang_isDeclaration(C.kind)); 1016 return ((uintptr_t) (C.data[1])) != 0; 1017 } 1018 1019 //===----------------------------------------------------------------------===// 1020 // libclang CXCursor APIs 1021 //===----------------------------------------------------------------------===// 1022 1023 extern "C" { 1024 1025 int clang_Cursor_isNull(CXCursor cursor) { 1026 return clang_equalCursors(cursor, clang_getNullCursor()); 1027 } 1028 1029 CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) { 1030 return getCursorTU(cursor); 1031 } 1032 1033 int clang_Cursor_getNumArguments(CXCursor C) { 1034 if (clang_isDeclaration(C.kind)) { 1035 const Decl *D = cxcursor::getCursorDecl(C); 1036 if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D)) 1037 return MD->param_size(); 1038 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 1039 return FD->param_size(); 1040 } 1041 1042 if (clang_isExpression(C.kind)) { 1043 const Expr *E = cxcursor::getCursorExpr(C); 1044 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) { 1045 return CE->getNumArgs(); 1046 } 1047 } 1048 1049 return -1; 1050 } 1051 1052 CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i) { 1053 if (clang_isDeclaration(C.kind)) { 1054 const Decl *D = cxcursor::getCursorDecl(C); 1055 if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D)) { 1056 if (i < MD->param_size()) 1057 return cxcursor::MakeCXCursor(MD->parameters()[i], 1058 cxcursor::getCursorTU(C)); 1059 } else if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) { 1060 if (i < FD->param_size()) 1061 return cxcursor::MakeCXCursor(FD->parameters()[i], 1062 cxcursor::getCursorTU(C)); 1063 } 1064 } 1065 1066 if (clang_isExpression(C.kind)) { 1067 const Expr *E = cxcursor::getCursorExpr(C); 1068 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) { 1069 if (i < CE->getNumArgs()) { 1070 return cxcursor::MakeCXCursor(CE->getArg(i), 1071 getCursorDecl(C), 1072 cxcursor::getCursorTU(C)); 1073 } 1074 } 1075 } 1076 1077 return clang_getNullCursor(); 1078 } 1079 1080 int clang_Cursor_getNumTemplateArguments(CXCursor C) { 1081 if (clang_getCursorKind(C) != CXCursor_FunctionDecl) { 1082 return -1; 1083 } 1084 1085 const FunctionDecl *FD = llvm::dyn_cast_or_null<clang::FunctionDecl>( 1086 getCursorDecl(C)); 1087 if (!FD) { 1088 return -1; 1089 } 1090 1091 const FunctionTemplateSpecializationInfo* SpecInfo = 1092 FD->getTemplateSpecializationInfo(); 1093 if (!SpecInfo) { 1094 return -1; 1095 } 1096 1097 return SpecInfo->TemplateArguments->size(); 1098 } 1099 1100 enum CXGetTemplateArgumentStatus { 1101 /** \brief The operation completed successfully */ 1102 CXGetTemplateArgumentStatus_Success = 0, 1103 1104 /** \brief The specified cursor did not represent a FunctionDecl. */ 1105 CXGetTemplateArgumentStatus_CursorNotFunctionDecl = -1, 1106 1107 /** \brief The specified cursor was not castable to a FunctionDecl. */ 1108 CXGetTemplateArgumentStatus_BadFunctionDeclCast = -2, 1109 1110 /** \brief A NULL FunctionTemplateSpecializationInfo was retrieved. */ 1111 CXGetTemplateArgumentStatus_NullTemplSpecInfo = -3, 1112 1113 /** \brief An invalid (OOB) argument index was specified */ 1114 CXGetTemplateArgumentStatus_InvalidIndex = -4 1115 }; 1116 1117 static int clang_Cursor_getTemplateArgument( 1118 CXCursor C, unsigned I, TemplateArgument *TA) { 1119 if (clang_getCursorKind(C) != CXCursor_FunctionDecl) { 1120 return CXGetTemplateArgumentStatus_CursorNotFunctionDecl; 1121 } 1122 1123 const FunctionDecl *FD = llvm::dyn_cast_or_null<clang::FunctionDecl>( 1124 getCursorDecl(C)); 1125 if (!FD) { 1126 return CXGetTemplateArgumentStatus_BadFunctionDeclCast; 1127 } 1128 1129 const FunctionTemplateSpecializationInfo* SpecInfo = 1130 FD->getTemplateSpecializationInfo(); 1131 if (!SpecInfo) { 1132 return CXGetTemplateArgumentStatus_NullTemplSpecInfo; 1133 } 1134 1135 if (I >= SpecInfo->TemplateArguments->size()) { 1136 return CXGetTemplateArgumentStatus_InvalidIndex; 1137 } 1138 1139 *TA = SpecInfo->TemplateArguments->get(I); 1140 return 0; 1141 } 1142 1143 enum CXTemplateArgumentKind clang_Cursor_getTemplateArgumentKind(CXCursor C, 1144 unsigned I) { 1145 TemplateArgument TA; 1146 if (clang_Cursor_getTemplateArgument(C, I, &TA)) { 1147 return CXTemplateArgumentKind_Invalid; 1148 } 1149 1150 switch (TA.getKind()) { 1151 case TemplateArgument::Null: return CXTemplateArgumentKind_Null; 1152 case TemplateArgument::Type: return CXTemplateArgumentKind_Type; 1153 case TemplateArgument::Declaration: 1154 return CXTemplateArgumentKind_Declaration; 1155 case TemplateArgument::NullPtr: return CXTemplateArgumentKind_NullPtr; 1156 case TemplateArgument::Integral: return CXTemplateArgumentKind_Integral; 1157 case TemplateArgument::Template: return CXTemplateArgumentKind_Template; 1158 case TemplateArgument::TemplateExpansion: 1159 return CXTemplateArgumentKind_TemplateExpansion; 1160 case TemplateArgument::Expression: return CXTemplateArgumentKind_Expression; 1161 case TemplateArgument::Pack: return CXTemplateArgumentKind_Pack; 1162 } 1163 1164 return CXTemplateArgumentKind_Invalid; 1165 } 1166 1167 CXType clang_Cursor_getTemplateArgumentType(CXCursor C, unsigned I) { 1168 TemplateArgument TA; 1169 if (clang_Cursor_getTemplateArgument(C, I, &TA) != 1170 CXGetTemplateArgumentStatus_Success) { 1171 return cxtype::MakeCXType(QualType(), getCursorTU(C)); 1172 } 1173 1174 if (TA.getKind() != TemplateArgument::Type) { 1175 return cxtype::MakeCXType(QualType(), getCursorTU(C)); 1176 } 1177 1178 return cxtype::MakeCXType(TA.getAsType(), getCursorTU(C)); 1179 } 1180 1181 long long clang_Cursor_getTemplateArgumentValue(CXCursor C, unsigned I) { 1182 TemplateArgument TA; 1183 if (clang_Cursor_getTemplateArgument(C, I, &TA) != 1184 CXGetTemplateArgumentStatus_Success) { 1185 assert(0 && "Unable to retrieve TemplateArgument"); 1186 return 0; 1187 } 1188 1189 if (TA.getKind() != TemplateArgument::Integral) { 1190 assert(0 && "Passed template argument is not Integral"); 1191 return 0; 1192 } 1193 1194 return TA.getAsIntegral().getSExtValue(); 1195 } 1196 1197 unsigned long long clang_Cursor_getTemplateArgumentUnsignedValue(CXCursor C, 1198 unsigned I) { 1199 TemplateArgument TA; 1200 if (clang_Cursor_getTemplateArgument(C, I, &TA) != 1201 CXGetTemplateArgumentStatus_Success) { 1202 assert(0 && "Unable to retrieve TemplateArgument"); 1203 return 0; 1204 } 1205 1206 if (TA.getKind() != TemplateArgument::Integral) { 1207 assert(0 && "Passed template argument is not Integral"); 1208 return 0; 1209 } 1210 1211 return TA.getAsIntegral().getZExtValue(); 1212 } 1213 1214 } // end: extern "C" 1215 1216 //===----------------------------------------------------------------------===// 1217 // CXCursorSet. 1218 //===----------------------------------------------------------------------===// 1219 1220 typedef llvm::DenseMap<CXCursor, unsigned> CXCursorSet_Impl; 1221 1222 static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) { 1223 return (CXCursorSet) setImpl; 1224 } 1225 static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) { 1226 return (CXCursorSet_Impl*) set; 1227 } 1228 namespace llvm { 1229 template<> struct DenseMapInfo<CXCursor> { 1230 public: 1231 static inline CXCursor getEmptyKey() { 1232 return MakeCXCursorInvalid(CXCursor_InvalidFile); 1233 } 1234 static inline CXCursor getTombstoneKey() { 1235 return MakeCXCursorInvalid(CXCursor_NoDeclFound); 1236 } 1237 static inline unsigned getHashValue(const CXCursor &cursor) { 1238 return llvm::DenseMapInfo<std::pair<const void *, const void *> > 1239 ::getHashValue(std::make_pair(cursor.data[0], cursor.data[1])); 1240 } 1241 static inline bool isEqual(const CXCursor &x, const CXCursor &y) { 1242 return x.kind == y.kind && 1243 x.data[0] == y.data[0] && 1244 x.data[1] == y.data[1]; 1245 } 1246 }; 1247 } 1248 1249 extern "C" { 1250 CXCursorSet clang_createCXCursorSet() { 1251 return packCXCursorSet(new CXCursorSet_Impl()); 1252 } 1253 1254 void clang_disposeCXCursorSet(CXCursorSet set) { 1255 delete unpackCXCursorSet(set); 1256 } 1257 1258 unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) { 1259 CXCursorSet_Impl *setImpl = unpackCXCursorSet(set); 1260 if (!setImpl) 1261 return 0; 1262 return setImpl->find(cursor) != setImpl->end(); 1263 } 1264 1265 unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) { 1266 // Do not insert invalid cursors into the set. 1267 if (cursor.kind >= CXCursor_FirstInvalid && 1268 cursor.kind <= CXCursor_LastInvalid) 1269 return 1; 1270 1271 CXCursorSet_Impl *setImpl = unpackCXCursorSet(set); 1272 if (!setImpl) 1273 return 1; 1274 unsigned &entry = (*setImpl)[cursor]; 1275 unsigned flag = entry == 0 ? 1 : 0; 1276 entry = 1; 1277 return flag; 1278 } 1279 1280 CXCompletionString clang_getCursorCompletionString(CXCursor cursor) { 1281 enum CXCursorKind kind = clang_getCursorKind(cursor); 1282 if (clang_isDeclaration(kind)) { 1283 const Decl *decl = getCursorDecl(cursor); 1284 if (const NamedDecl *namedDecl = dyn_cast_or_null<NamedDecl>(decl)) { 1285 ASTUnit *unit = getCursorASTUnit(cursor); 1286 CodeCompletionResult Result(namedDecl, CCP_Declaration); 1287 CodeCompletionString *String 1288 = Result.CreateCodeCompletionString(unit->getASTContext(), 1289 unit->getPreprocessor(), 1290 unit->getCodeCompletionTUInfo().getAllocator(), 1291 unit->getCodeCompletionTUInfo(), 1292 true); 1293 return String; 1294 } 1295 } else if (kind == CXCursor_MacroDefinition) { 1296 const MacroDefinitionRecord *definition = getCursorMacroDefinition(cursor); 1297 const IdentifierInfo *MacroInfo = definition->getName(); 1298 ASTUnit *unit = getCursorASTUnit(cursor); 1299 CodeCompletionResult Result(MacroInfo); 1300 CodeCompletionString *String = Result.CreateCodeCompletionString( 1301 unit->getASTContext(), unit->getPreprocessor(), 1302 unit->getCodeCompletionTUInfo().getAllocator(), 1303 unit->getCodeCompletionTUInfo(), false); 1304 return String; 1305 } 1306 return nullptr; 1307 } 1308 } // end: extern C. 1309 1310 namespace { 1311 struct OverridenCursorsPool { 1312 typedef SmallVector<CXCursor, 2> CursorVec; 1313 std::vector<CursorVec*> AllCursors; 1314 std::vector<CursorVec*> AvailableCursors; 1315 1316 ~OverridenCursorsPool() { 1317 for (std::vector<CursorVec*>::iterator I = AllCursors.begin(), 1318 E = AllCursors.end(); I != E; ++I) { 1319 delete *I; 1320 } 1321 } 1322 }; 1323 } 1324 1325 void *cxcursor::createOverridenCXCursorsPool() { 1326 return new OverridenCursorsPool(); 1327 } 1328 1329 void cxcursor::disposeOverridenCXCursorsPool(void *pool) { 1330 delete static_cast<OverridenCursorsPool*>(pool); 1331 } 1332 1333 extern "C" { 1334 void clang_getOverriddenCursors(CXCursor cursor, 1335 CXCursor **overridden, 1336 unsigned *num_overridden) { 1337 if (overridden) 1338 *overridden = nullptr; 1339 if (num_overridden) 1340 *num_overridden = 0; 1341 1342 CXTranslationUnit TU = cxcursor::getCursorTU(cursor); 1343 1344 if (!overridden || !num_overridden || !TU) 1345 return; 1346 1347 if (!clang_isDeclaration(cursor.kind)) 1348 return; 1349 1350 OverridenCursorsPool &pool = 1351 *static_cast<OverridenCursorsPool*>(TU->OverridenCursorsPool); 1352 1353 OverridenCursorsPool::CursorVec *Vec = nullptr; 1354 1355 if (!pool.AvailableCursors.empty()) { 1356 Vec = pool.AvailableCursors.back(); 1357 pool.AvailableCursors.pop_back(); 1358 } 1359 else { 1360 Vec = new OverridenCursorsPool::CursorVec(); 1361 pool.AllCursors.push_back(Vec); 1362 } 1363 1364 // Clear out the vector, but don't free the memory contents. This 1365 // reduces malloc() traffic. 1366 Vec->clear(); 1367 1368 // Use the first entry to contain a back reference to the vector. 1369 // This is a complete hack. 1370 CXCursor backRefCursor = MakeCXCursorInvalid(CXCursor_InvalidFile, TU); 1371 backRefCursor.data[0] = Vec; 1372 assert(cxcursor::getCursorTU(backRefCursor) == TU); 1373 Vec->push_back(backRefCursor); 1374 1375 // Get the overriden cursors. 1376 cxcursor::getOverriddenCursors(cursor, *Vec); 1377 1378 // Did we get any overriden cursors? If not, return Vec to the pool 1379 // of available cursor vectors. 1380 if (Vec->size() == 1) { 1381 pool.AvailableCursors.push_back(Vec); 1382 return; 1383 } 1384 1385 // Now tell the caller about the overriden cursors. 1386 assert(Vec->size() > 1); 1387 *overridden = &((*Vec)[1]); 1388 *num_overridden = Vec->size() - 1; 1389 } 1390 1391 void clang_disposeOverriddenCursors(CXCursor *overridden) { 1392 if (!overridden) 1393 return; 1394 1395 // Use pointer arithmetic to get back the first faux entry 1396 // which has a back-reference to the TU and the vector. 1397 --overridden; 1398 OverridenCursorsPool::CursorVec *Vec = 1399 static_cast<OverridenCursorsPool::CursorVec *>( 1400 const_cast<void *>(overridden->data[0])); 1401 CXTranslationUnit TU = getCursorTU(*overridden); 1402 1403 assert(Vec && TU); 1404 1405 OverridenCursorsPool &pool = 1406 *static_cast<OverridenCursorsPool*>(TU->OverridenCursorsPool); 1407 1408 pool.AvailableCursors.push_back(Vec); 1409 } 1410 1411 int clang_Cursor_isDynamicCall(CXCursor C) { 1412 const Expr *E = nullptr; 1413 if (clang_isExpression(C.kind)) 1414 E = getCursorExpr(C); 1415 if (!E) 1416 return 0; 1417 1418 if (const ObjCMessageExpr *MsgE = dyn_cast<ObjCMessageExpr>(E)) { 1419 if (MsgE->getReceiverKind() != ObjCMessageExpr::Instance) 1420 return false; 1421 if (auto *RecE = dyn_cast<ObjCMessageExpr>( 1422 MsgE->getInstanceReceiver()->IgnoreParenCasts())) { 1423 if (RecE->getMethodFamily() == OMF_alloc) 1424 return false; 1425 } 1426 return true; 1427 } 1428 1429 const MemberExpr *ME = nullptr; 1430 if (isa<MemberExpr>(E)) 1431 ME = cast<MemberExpr>(E); 1432 else if (const CallExpr *CE = dyn_cast<CallExpr>(E)) 1433 ME = dyn_cast_or_null<MemberExpr>(CE->getCallee()); 1434 1435 if (ME) { 1436 if (const CXXMethodDecl * 1437 MD = dyn_cast_or_null<CXXMethodDecl>(ME->getMemberDecl())) 1438 return MD->isVirtual() && !ME->hasQualifier(); 1439 } 1440 1441 return 0; 1442 } 1443 1444 CXType clang_Cursor_getReceiverType(CXCursor C) { 1445 CXTranslationUnit TU = cxcursor::getCursorTU(C); 1446 const Expr *E = nullptr; 1447 if (clang_isExpression(C.kind)) 1448 E = getCursorExpr(C); 1449 1450 if (const ObjCMessageExpr *MsgE = dyn_cast_or_null<ObjCMessageExpr>(E)) 1451 return cxtype::MakeCXType(MsgE->getReceiverType(), TU); 1452 1453 return cxtype::MakeCXType(QualType(), TU); 1454 } 1455 1456 } // end: extern "C" 1457