xref: /llvm-project/clang/tools/libclang/CXCursor.cpp (revision a1bcb6adb5f1b4f209adde0c5a4edf39ef281bac) 
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/Expr.h"
24 #include "clang/AST/ExprCXX.h"
25 #include "clang-c/Index.h"
26 #include "llvm/Support/ErrorHandling.h"
27 
28 using namespace clang;
29 using namespace cxcursor;
30 
31 CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K) {
32   assert(K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid);
33   CXCursor C = { K, { 0, 0, 0 } };
34   return C;
35 }
36 
37 static CXCursorKind GetCursorKind(const Attr *A) {
38   assert(A && "Invalid arguments!");
39   switch (A->getKind()) {
40     default: break;
41     case attr::IBAction: return CXCursor_IBActionAttr;
42     case attr::IBOutlet: return CXCursor_IBOutletAttr;
43     case attr::IBOutletCollection: return CXCursor_IBOutletCollectionAttr;
44     case attr::Final: return CXCursor_CXXFinalAttr;
45     case attr::Override: return CXCursor_CXXOverrideAttr;
46   }
47 
48   return CXCursor_UnexposedAttr;
49 }
50 
51 CXCursor cxcursor::MakeCXCursor(const Attr *A, Decl *Parent,
52                                 CXTranslationUnit TU) {
53   assert(A && Parent && TU && "Invalid arguments!");
54   CXCursor C = { GetCursorKind(A), { Parent, (void*)A, TU } };
55   return C;
56 }
57 
58 CXCursor cxcursor::MakeCXCursor(Decl *D, CXTranslationUnit TU,
59                                 bool FirstInDeclGroup) {
60   assert(D && TU && "Invalid arguments!");
61   CXCursor C = { getCursorKindForDecl(D),
62                  { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }
63                };
64   return C;
65 }
66 
67 CXCursor cxcursor::MakeCXCursor(Stmt *S, Decl *Parent,
68                                 CXTranslationUnit TU) {
69   assert(S && TU && "Invalid arguments!");
70   CXCursorKind K = CXCursor_NotImplemented;
71 
72   switch (S->getStmtClass()) {
73   case Stmt::NoStmtClass:
74     break;
75 
76   case Stmt::NullStmtClass:
77   case Stmt::CompoundStmtClass:
78   case Stmt::CaseStmtClass:
79   case Stmt::DefaultStmtClass:
80   case Stmt::IfStmtClass:
81   case Stmt::SwitchStmtClass:
82   case Stmt::WhileStmtClass:
83   case Stmt::DoStmtClass:
84   case Stmt::ForStmtClass:
85   case Stmt::GotoStmtClass:
86   case Stmt::IndirectGotoStmtClass:
87   case Stmt::ContinueStmtClass:
88   case Stmt::BreakStmtClass:
89   case Stmt::ReturnStmtClass:
90   case Stmt::DeclStmtClass:
91   case Stmt::AsmStmtClass:
92   case Stmt::ObjCAtTryStmtClass:
93   case Stmt::ObjCAtCatchStmtClass:
94   case Stmt::ObjCAtFinallyStmtClass:
95   case Stmt::ObjCAtThrowStmtClass:
96   case Stmt::ObjCAtSynchronizedStmtClass:
97   case Stmt::ObjCAutoreleasePoolStmtClass:
98   case Stmt::ObjCForCollectionStmtClass:
99   case Stmt::CXXCatchStmtClass:
100   case Stmt::CXXTryStmtClass:
101   case Stmt::CXXForRangeStmtClass:
102   case Stmt::SEHTryStmtClass:
103   case Stmt::SEHExceptStmtClass:
104   case Stmt::SEHFinallyStmtClass:
105   case Stmt::MaterializeTemporaryExprClass:
106     K = CXCursor_UnexposedStmt;
107     break;
108 
109   case Stmt::LabelStmtClass:
110     K = CXCursor_LabelStmt;
111     break;
112 
113   case Stmt::PredefinedExprClass:
114   case Stmt::IntegerLiteralClass:
115   case Stmt::FloatingLiteralClass:
116   case Stmt::ImaginaryLiteralClass:
117   case Stmt::StringLiteralClass:
118   case Stmt::CharacterLiteralClass:
119   case Stmt::ParenExprClass:
120   case Stmt::UnaryOperatorClass:
121   case Stmt::OffsetOfExprClass:
122   case Stmt::UnaryExprOrTypeTraitExprClass:
123   case Stmt::ArraySubscriptExprClass:
124   case Stmt::BinaryOperatorClass:
125   case Stmt::CompoundAssignOperatorClass:
126   case Stmt::ConditionalOperatorClass:
127   case Stmt::BinaryConditionalOperatorClass:
128   case Stmt::ImplicitCastExprClass:
129   case Stmt::CStyleCastExprClass:
130   case Stmt::CompoundLiteralExprClass:
131   case Stmt::ExtVectorElementExprClass:
132   case Stmt::InitListExprClass:
133   case Stmt::DesignatedInitExprClass:
134   case Stmt::ImplicitValueInitExprClass:
135   case Stmt::ParenListExprClass:
136   case Stmt::VAArgExprClass:
137   case Stmt::AddrLabelExprClass:
138   case Stmt::StmtExprClass:
139   case Stmt::ChooseExprClass:
140   case Stmt::GenericSelectionExprClass:
141   case Stmt::GNUNullExprClass:
142   case Stmt::CXXStaticCastExprClass:
143   case Stmt::CXXDynamicCastExprClass:
144   case Stmt::CXXReinterpretCastExprClass:
145   case Stmt::CXXConstCastExprClass:
146   case Stmt::CXXFunctionalCastExprClass:
147   case Stmt::CXXTypeidExprClass:
148   case Stmt::CXXUuidofExprClass:
149   case Stmt::CXXBoolLiteralExprClass:
150   case Stmt::CXXNullPtrLiteralExprClass:
151   case Stmt::CXXThisExprClass:
152   case Stmt::CXXThrowExprClass:
153   case Stmt::CXXDefaultArgExprClass:
154   case Stmt::CXXScalarValueInitExprClass:
155   case Stmt::CXXNewExprClass:
156   case Stmt::CXXDeleteExprClass:
157   case Stmt::CXXPseudoDestructorExprClass:
158   case Stmt::UnresolvedLookupExprClass:
159   case Stmt::UnaryTypeTraitExprClass:
160   case Stmt::BinaryTypeTraitExprClass:
161   case Stmt::ArrayTypeTraitExprClass:
162   case Stmt::ExpressionTraitExprClass:
163   case Stmt::DependentScopeDeclRefExprClass:
164   case Stmt::CXXBindTemporaryExprClass:
165   case Stmt::ExprWithCleanupsClass:
166   case Stmt::CXXUnresolvedConstructExprClass:
167   case Stmt::CXXDependentScopeMemberExprClass:
168   case Stmt::UnresolvedMemberExprClass:
169   case Stmt::CXXNoexceptExprClass:
170   case Stmt::ObjCStringLiteralClass:
171   case Stmt::ObjCEncodeExprClass:
172   case Stmt::ObjCSelectorExprClass:
173   case Stmt::ObjCProtocolExprClass:
174   case Stmt::ObjCIsaExprClass:
175   case Stmt::ObjCIndirectCopyRestoreExprClass:
176   case Stmt::ObjCBridgedCastExprClass:
177   case Stmt::ShuffleVectorExprClass:
178   case Stmt::BlockExprClass:
179   case Stmt::OpaqueValueExprClass:
180   case Stmt::PackExpansionExprClass:
181   case Stmt::SizeOfPackExprClass:
182   case Stmt::AsTypeExprClass:
183     K = CXCursor_UnexposedExpr;
184     break;
185 
186   case Stmt::DeclRefExprClass:
187   case Stmt::BlockDeclRefExprClass:
188   case Stmt::SubstNonTypeTemplateParmExprClass:
189   case Stmt::SubstNonTypeTemplateParmPackExprClass:
190     // FIXME: UnresolvedLookupExpr?
191     // FIXME: DependentScopeDeclRefExpr?
192     K = CXCursor_DeclRefExpr;
193     break;
194 
195   case Stmt::MemberExprClass:
196   case Stmt::ObjCIvarRefExprClass:
197   case Stmt::ObjCPropertyRefExprClass:
198     // FIXME: UnresolvedMemberExpr?
199     // FIXME: CXXDependentScopeMemberExpr?
200     K = CXCursor_MemberRefExpr;
201     break;
202 
203   case Stmt::CallExprClass:
204   case Stmt::CXXOperatorCallExprClass:
205   case Stmt::CXXMemberCallExprClass:
206   case Stmt::CUDAKernelCallExprClass:
207   case Stmt::CXXConstructExprClass:
208   case Stmt::CXXTemporaryObjectExprClass:
209     // FIXME: CXXUnresolvedConstructExpr
210     K = CXCursor_CallExpr;
211     break;
212 
213   case Stmt::ObjCMessageExprClass:
214     K = CXCursor_ObjCMessageExpr;
215     break;
216   }
217 
218   CXCursor C = { K, { Parent, S, TU } };
219   return C;
220 }
221 
222 CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
223                                                SourceLocation Loc,
224                                                CXTranslationUnit TU) {
225   assert(Super && TU && "Invalid arguments!");
226   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
227   CXCursor C = { CXCursor_ObjCSuperClassRef, { Super, RawLoc, TU } };
228   return C;
229 }
230 
231 std::pair<ObjCInterfaceDecl *, SourceLocation>
232 cxcursor::getCursorObjCSuperClassRef(CXCursor C) {
233   assert(C.kind == CXCursor_ObjCSuperClassRef);
234   return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]),
235            SourceLocation::getFromRawEncoding(
236                                       reinterpret_cast<uintptr_t>(C.data[1])));
237 }
238 
239 CXCursor cxcursor::MakeCursorObjCProtocolRef(ObjCProtocolDecl *Super,
240                                              SourceLocation Loc,
241                                              CXTranslationUnit TU) {
242   assert(Super && TU && "Invalid arguments!");
243   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
244   CXCursor C = { CXCursor_ObjCProtocolRef, { Super, RawLoc, TU } };
245   return C;
246 }
247 
248 std::pair<ObjCProtocolDecl *, SourceLocation>
249 cxcursor::getCursorObjCProtocolRef(CXCursor C) {
250   assert(C.kind == CXCursor_ObjCProtocolRef);
251   return std::make_pair(static_cast<ObjCProtocolDecl *>(C.data[0]),
252            SourceLocation::getFromRawEncoding(
253                                       reinterpret_cast<uintptr_t>(C.data[1])));
254 }
255 
256 CXCursor cxcursor::MakeCursorObjCClassRef(ObjCInterfaceDecl *Class,
257                                           SourceLocation Loc,
258                                           CXTranslationUnit TU) {
259   // 'Class' can be null for invalid code.
260   if (!Class)
261     return MakeCXCursorInvalid(CXCursor_InvalidCode);
262   assert(TU && "Invalid arguments!");
263   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
264   CXCursor C = { CXCursor_ObjCClassRef, { Class, RawLoc, TU } };
265   return C;
266 }
267 
268 std::pair<ObjCInterfaceDecl *, SourceLocation>
269 cxcursor::getCursorObjCClassRef(CXCursor C) {
270   assert(C.kind == CXCursor_ObjCClassRef);
271   return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]),
272            SourceLocation::getFromRawEncoding(
273                                       reinterpret_cast<uintptr_t>(C.data[1])));
274 }
275 
276 CXCursor cxcursor::MakeCursorTypeRef(TypeDecl *Type, SourceLocation Loc,
277                                      CXTranslationUnit TU) {
278   assert(Type && TU && "Invalid arguments!");
279   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
280   CXCursor C = { CXCursor_TypeRef, { Type, RawLoc, TU } };
281   return C;
282 }
283 
284 std::pair<TypeDecl *, SourceLocation>
285 cxcursor::getCursorTypeRef(CXCursor C) {
286   assert(C.kind == CXCursor_TypeRef);
287   return std::make_pair(static_cast<TypeDecl *>(C.data[0]),
288            SourceLocation::getFromRawEncoding(
289                                       reinterpret_cast<uintptr_t>(C.data[1])));
290 }
291 
292 CXCursor cxcursor::MakeCursorTemplateRef(TemplateDecl *Template,
293                                          SourceLocation Loc,
294                                          CXTranslationUnit TU) {
295   assert(Template && TU && "Invalid arguments!");
296   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
297   CXCursor C = { CXCursor_TemplateRef, { Template, RawLoc, TU } };
298   return C;
299 }
300 
301 std::pair<TemplateDecl *, SourceLocation>
302 cxcursor::getCursorTemplateRef(CXCursor C) {
303   assert(C.kind == CXCursor_TemplateRef);
304   return std::make_pair(static_cast<TemplateDecl *>(C.data[0]),
305                         SourceLocation::getFromRawEncoding(
306                                        reinterpret_cast<uintptr_t>(C.data[1])));
307 }
308 
309 CXCursor cxcursor::MakeCursorNamespaceRef(NamedDecl *NS, SourceLocation Loc,
310                                           CXTranslationUnit TU) {
311 
312   assert(NS && (isa<NamespaceDecl>(NS) || isa<NamespaceAliasDecl>(NS)) && TU &&
313          "Invalid arguments!");
314   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
315   CXCursor C = { CXCursor_NamespaceRef, { NS, RawLoc, TU } };
316   return C;
317 }
318 
319 std::pair<NamedDecl *, SourceLocation>
320 cxcursor::getCursorNamespaceRef(CXCursor C) {
321   assert(C.kind == CXCursor_NamespaceRef);
322   return std::make_pair(static_cast<NamedDecl *>(C.data[0]),
323                         SourceLocation::getFromRawEncoding(
324                                        reinterpret_cast<uintptr_t>(C.data[1])));
325 }
326 
327 CXCursor cxcursor::MakeCursorMemberRef(FieldDecl *Field, SourceLocation Loc,
328                                        CXTranslationUnit TU) {
329 
330   assert(Field && TU && "Invalid arguments!");
331   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
332   CXCursor C = { CXCursor_MemberRef, { Field, RawLoc, TU } };
333   return C;
334 }
335 
336 std::pair<FieldDecl *, SourceLocation>
337 cxcursor::getCursorMemberRef(CXCursor C) {
338   assert(C.kind == CXCursor_MemberRef);
339   return std::make_pair(static_cast<FieldDecl *>(C.data[0]),
340                         SourceLocation::getFromRawEncoding(
341                                        reinterpret_cast<uintptr_t>(C.data[1])));
342 }
343 
344 CXCursor cxcursor::MakeCursorCXXBaseSpecifier(CXXBaseSpecifier *B,
345                                               CXTranslationUnit TU){
346   CXCursor C = { CXCursor_CXXBaseSpecifier, { B, 0, TU } };
347   return C;
348 }
349 
350 CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) {
351   assert(C.kind == CXCursor_CXXBaseSpecifier);
352   return static_cast<CXXBaseSpecifier*>(C.data[0]);
353 }
354 
355 CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range,
356                                                     CXTranslationUnit TU) {
357   CXCursor C = { CXCursor_PreprocessingDirective,
358                  { reinterpret_cast<void *>(Range.getBegin().getRawEncoding()),
359                    reinterpret_cast<void *>(Range.getEnd().getRawEncoding()),
360                    TU }
361                };
362   return C;
363 }
364 
365 SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) {
366   assert(C.kind == CXCursor_PreprocessingDirective);
367   SourceRange Range = SourceRange(SourceLocation::getFromRawEncoding(
368                                       reinterpret_cast<uintptr_t> (C.data[0])),
369                      SourceLocation::getFromRawEncoding(
370                                       reinterpret_cast<uintptr_t> (C.data[1])));
371   ASTUnit *TU = getCursorASTUnit(C);
372   return TU->mapRangeFromPreamble(Range);
373 }
374 
375 CXCursor cxcursor::MakeMacroDefinitionCursor(MacroDefinition *MI,
376                                              CXTranslationUnit TU) {
377   CXCursor C = { CXCursor_MacroDefinition, { MI, 0, TU } };
378   return C;
379 }
380 
381 MacroDefinition *cxcursor::getCursorMacroDefinition(CXCursor C) {
382   assert(C.kind == CXCursor_MacroDefinition);
383   return static_cast<MacroDefinition *>(C.data[0]);
384 }
385 
386 CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI,
387                                             CXTranslationUnit TU) {
388   CXCursor C = { CXCursor_MacroExpansion, { MI, 0, TU } };
389   return C;
390 }
391 
392 MacroExpansion *cxcursor::getCursorMacroExpansion(CXCursor C) {
393   assert(C.kind == CXCursor_MacroExpansion);
394   return static_cast<MacroExpansion *>(C.data[0]);
395 }
396 
397 CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID,
398                                                 CXTranslationUnit TU) {
399   CXCursor C = { CXCursor_InclusionDirective, { ID, 0, TU } };
400   return C;
401 }
402 
403 InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) {
404   assert(C.kind == CXCursor_InclusionDirective);
405   return static_cast<InclusionDirective *>(C.data[0]);
406 }
407 
408 CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc,
409                                       CXTranslationUnit TU) {
410 
411   assert(Label && TU && "Invalid arguments!");
412   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
413   CXCursor C = { CXCursor_LabelRef, { Label, RawLoc, TU } };
414   return C;
415 }
416 
417 std::pair<LabelStmt*, SourceLocation>
418 cxcursor::getCursorLabelRef(CXCursor C) {
419   assert(C.kind == CXCursor_LabelRef);
420   return std::make_pair(static_cast<LabelStmt *>(C.data[0]),
421                         SourceLocation::getFromRawEncoding(
422                                        reinterpret_cast<uintptr_t>(C.data[1])));
423 }
424 
425 CXCursor cxcursor::MakeCursorOverloadedDeclRef(OverloadExpr *E,
426                                                CXTranslationUnit TU) {
427   assert(E && TU && "Invalid arguments!");
428   OverloadedDeclRefStorage Storage(E);
429   void *RawLoc = reinterpret_cast<void *>(E->getNameLoc().getRawEncoding());
430   CXCursor C = {
431                  CXCursor_OverloadedDeclRef,
432                  { Storage.getOpaqueValue(), RawLoc, TU }
433                };
434   return C;
435 }
436 
437 CXCursor cxcursor::MakeCursorOverloadedDeclRef(Decl *D,
438                                                SourceLocation Loc,
439                                                CXTranslationUnit TU) {
440   assert(D && TU && "Invalid arguments!");
441   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
442   OverloadedDeclRefStorage Storage(D);
443   CXCursor C = {
444     CXCursor_OverloadedDeclRef,
445     { Storage.getOpaqueValue(), RawLoc, TU }
446   };
447   return C;
448 }
449 
450 CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name,
451                                                SourceLocation Loc,
452                                                CXTranslationUnit TU) {
453   assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!");
454   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
455   OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate());
456   CXCursor C = {
457     CXCursor_OverloadedDeclRef,
458     { Storage.getOpaqueValue(), RawLoc, TU }
459   };
460   return C;
461 }
462 
463 std::pair<cxcursor::OverloadedDeclRefStorage, SourceLocation>
464 cxcursor::getCursorOverloadedDeclRef(CXCursor C) {
465   assert(C.kind == CXCursor_OverloadedDeclRef);
466   return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue(C.data[0]),
467                         SourceLocation::getFromRawEncoding(
468                                        reinterpret_cast<uintptr_t>(C.data[1])));
469 }
470 
471 Decl *cxcursor::getCursorDecl(CXCursor Cursor) {
472   return (Decl *)Cursor.data[0];
473 }
474 
475 Expr *cxcursor::getCursorExpr(CXCursor Cursor) {
476   return dyn_cast_or_null<Expr>(getCursorStmt(Cursor));
477 }
478 
479 Stmt *cxcursor::getCursorStmt(CXCursor Cursor) {
480   if (Cursor.kind == CXCursor_ObjCSuperClassRef ||
481       Cursor.kind == CXCursor_ObjCProtocolRef ||
482       Cursor.kind == CXCursor_ObjCClassRef)
483     return 0;
484 
485   return (Stmt *)Cursor.data[1];
486 }
487 
488 Attr *cxcursor::getCursorAttr(CXCursor Cursor) {
489   return (Attr *)Cursor.data[1];
490 }
491 
492 Decl *cxcursor::getCursorParentDecl(CXCursor Cursor) {
493   return (Decl *)Cursor.data[0];
494 }
495 
496 ASTContext &cxcursor::getCursorContext(CXCursor Cursor) {
497   return getCursorASTUnit(Cursor)->getASTContext();
498 }
499 
500 ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) {
501   return static_cast<ASTUnit *>(static_cast<CXTranslationUnit>(Cursor.data[2])
502                                   ->TUData);
503 }
504 
505 CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) {
506   return static_cast<CXTranslationUnit>(Cursor.data[2]);
507 }
508 
509 bool cxcursor::operator==(CXCursor X, CXCursor Y) {
510   return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] &&
511          X.data[2] == Y.data[2];
512 }
513 
514 // FIXME: Remove once we can model DeclGroups and their appropriate ranges
515 // properly in the ASTs.
516 bool cxcursor::isFirstInDeclGroup(CXCursor C) {
517   assert(clang_isDeclaration(C.kind));
518   return ((uintptr_t) (C.data[1])) != 0;
519 }
520 
521 //===----------------------------------------------------------------------===//
522 // libclang CXCursor APIs
523 //===----------------------------------------------------------------------===//
524 
525 extern "C" {
526 
527 int clang_Cursor_isNull(CXCursor cursor) {
528   return clang_equalCursors(cursor, clang_getNullCursor());
529 }
530 
531 CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) {
532   return getCursorTU(cursor);
533 }
534 
535 } // end: extern "C"
536 
537 //===----------------------------------------------------------------------===//
538 // CXCursorSet.
539 //===----------------------------------------------------------------------===//
540 
541 typedef llvm::DenseMap<CXCursor, unsigned> CXCursorSet_Impl;
542 
543 static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) {
544   return (CXCursorSet) setImpl;
545 }
546 static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) {
547   return (CXCursorSet_Impl*) set;
548 }
549 namespace llvm {
550 template<> struct DenseMapInfo<CXCursor> {
551 public:
552   static inline CXCursor getEmptyKey() {
553     return MakeCXCursorInvalid(CXCursor_InvalidFile);
554   }
555   static inline CXCursor getTombstoneKey() {
556     return MakeCXCursorInvalid(CXCursor_NoDeclFound);
557   }
558   static inline unsigned getHashValue(const CXCursor &cursor) {
559     return llvm::DenseMapInfo<std::pair<void*,void*> >
560       ::getHashValue(std::make_pair(cursor.data[0], cursor.data[1]));
561   }
562   static inline bool isEqual(const CXCursor &x, const CXCursor &y) {
563     return x.kind == y.kind &&
564            x.data[0] == y.data[0] &&
565            x.data[1] == y.data[1];
566   }
567 };
568 }
569 
570 extern "C" {
571 CXCursorSet clang_createCXCursorSet() {
572   return packCXCursorSet(new CXCursorSet_Impl());
573 }
574 
575 void clang_disposeCXCursorSet(CXCursorSet set) {
576   delete unpackCXCursorSet(set);
577 }
578 
579 unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) {
580   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
581   if (!setImpl)
582     return 0;
583   return setImpl->find(cursor) == setImpl->end();
584 }
585 
586 unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) {
587   // Do not insert invalid cursors into the set.
588   if (cursor.kind >= CXCursor_FirstInvalid &&
589       cursor.kind <= CXCursor_LastInvalid)
590     return 1;
591 
592   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
593   if (!setImpl)
594     return 1;
595   unsigned &entry = (*setImpl)[cursor];
596   unsigned flag = entry == 0 ? 1 : 0;
597   entry = 1;
598   return flag;
599 }
600 
601 CXCompletionString clang_getCursorCompletionString(CXCursor cursor) {
602   enum CXCursorKind kind = clang_getCursorKind(cursor);
603   if (clang_isDeclaration(kind)) {
604     Decl *decl = getCursorDecl(cursor);
605     if (isa<NamedDecl>(decl)) {
606       NamedDecl *namedDecl = (NamedDecl *)decl;
607       ASTUnit *unit = getCursorASTUnit(cursor);
608       if (unit->hasSema()) {
609         Sema &S = unit->getSema();
610         CodeCompletionAllocator *Allocator
611           = unit->getCursorCompletionAllocator().getPtr();
612         CodeCompletionResult Result(namedDecl);
613         CodeCompletionString *String
614           = Result.CreateCodeCompletionString(S, *Allocator);
615         return String;
616       }
617     }
618   }
619   else if (kind == CXCursor_MacroDefinition) {
620     MacroDefinition *definition = getCursorMacroDefinition(cursor);
621     const IdentifierInfo *MacroInfo = definition->getName();
622     ASTUnit *unit = getCursorASTUnit(cursor);
623     if (unit->hasSema()) {
624       Sema &S = unit->getSema();
625       CodeCompletionAllocator *Allocator
626         = unit->getCursorCompletionAllocator().getPtr();
627       CodeCompletionResult Result(const_cast<IdentifierInfo *>(MacroInfo));
628       CodeCompletionString *String
629         = Result.CreateCodeCompletionString(S, *Allocator);
630       return String;
631     }
632   }
633   return NULL;
634 }
635 
636 } // end: extern "C"
637