CXCursor.cpp revision 1f60d9ea523fc321d811fe880ba9a1ec74fa8f9b 
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 "CXCursor.h"
17#include "clang/Frontend/ASTUnit.h"
18#include "clang/AST/Decl.h"
19#include "clang/AST/DeclCXX.h"
20#include "clang/AST/DeclObjC.h"
21#include "clang/AST/Expr.h"
22#include "clang/AST/ExprCXX.h"
23#include "llvm/Support/ErrorHandling.h"
24
25using namespace clang;
26using namespace cxcursor;
27
28CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K) {
29  assert(K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid);
30  CXCursor C = { K, { 0, 0, 0 } };
31  return C;
32}
33
34static CXCursorKind GetCursorKind(const Attr *A) {
35  assert(A && "Invalid arguments!");
36  switch (A->getKind()) {
37    default: break;
38    case attr::IBAction: return CXCursor_IBActionAttr;
39    case attr::IBOutlet: return CXCursor_IBOutletAttr;
40    case attr::IBOutletCollection: return CXCursor_IBOutletCollectionAttr;
41  }
42
43  return CXCursor_UnexposedAttr;
44}
45
46CXCursor cxcursor::MakeCXCursor(const Attr *A, Decl *Parent, ASTUnit *TU) {
47  assert(A && Parent && TU && "Invalid arguments!");
48  CXCursor C = { GetCursorKind(A), { Parent, (void*)A, TU } };
49  return C;
50}
51
52CXCursor cxcursor::MakeCXCursor(Decl *D, ASTUnit *TU) {
53  assert(D && TU && "Invalid arguments!");
54  CXCursor C = { getCursorKindForDecl(D), { D, 0, TU } };
55  return C;
56}
57
58CXCursor cxcursor::MakeCXCursor(Stmt *S, Decl *Parent, ASTUnit *TU) {
59  assert(S && TU && "Invalid arguments!");
60  CXCursorKind K = CXCursor_NotImplemented;
61
62  switch (S->getStmtClass()) {
63  case Stmt::NoStmtClass:
64    break;
65
66  case Stmt::NullStmtClass:
67  case Stmt::CompoundStmtClass:
68  case Stmt::CaseStmtClass:
69  case Stmt::DefaultStmtClass:
70  case Stmt::IfStmtClass:
71  case Stmt::SwitchStmtClass:
72  case Stmt::WhileStmtClass:
73  case Stmt::DoStmtClass:
74  case Stmt::ForStmtClass:
75  case Stmt::GotoStmtClass:
76  case Stmt::IndirectGotoStmtClass:
77  case Stmt::ContinueStmtClass:
78  case Stmt::BreakStmtClass:
79  case Stmt::ReturnStmtClass:
80  case Stmt::DeclStmtClass:
81  case Stmt::SwitchCaseClass:
82  case Stmt::AsmStmtClass:
83  case Stmt::ObjCAtTryStmtClass:
84  case Stmt::ObjCAtCatchStmtClass:
85  case Stmt::ObjCAtFinallyStmtClass:
86  case Stmt::ObjCAtThrowStmtClass:
87  case Stmt::ObjCAtSynchronizedStmtClass:
88  case Stmt::ObjCForCollectionStmtClass:
89  case Stmt::CXXCatchStmtClass:
90  case Stmt::CXXTryStmtClass:
91    K = CXCursor_UnexposedStmt;
92    break;
93
94  case Stmt::LabelStmtClass:
95    K = CXCursor_LabelStmt;
96    break;
97
98  case Stmt::PredefinedExprClass:
99  case Stmt::IntegerLiteralClass:
100  case Stmt::FloatingLiteralClass:
101  case Stmt::ImaginaryLiteralClass:
102  case Stmt::StringLiteralClass:
103  case Stmt::CharacterLiteralClass:
104  case Stmt::ParenExprClass:
105  case Stmt::UnaryOperatorClass:
106  case Stmt::OffsetOfExprClass:
107  case Stmt::SizeOfAlignOfExprClass:
108  case Stmt::ArraySubscriptExprClass:
109  case Stmt::BinaryOperatorClass:
110  case Stmt::CompoundAssignOperatorClass:
111  case Stmt::ConditionalOperatorClass:
112  case Stmt::ImplicitCastExprClass:
113  case Stmt::CStyleCastExprClass:
114  case Stmt::CompoundLiteralExprClass:
115  case Stmt::ExtVectorElementExprClass:
116  case Stmt::InitListExprClass:
117  case Stmt::DesignatedInitExprClass:
118  case Stmt::ImplicitValueInitExprClass:
119  case Stmt::ParenListExprClass:
120  case Stmt::VAArgExprClass:
121  case Stmt::AddrLabelExprClass:
122  case Stmt::StmtExprClass:
123  case Stmt::TypesCompatibleExprClass:
124  case Stmt::ChooseExprClass:
125  case Stmt::GNUNullExprClass:
126  case Stmt::CXXStaticCastExprClass:
127  case Stmt::CXXDynamicCastExprClass:
128  case Stmt::CXXReinterpretCastExprClass:
129  case Stmt::CXXConstCastExprClass:
130  case Stmt::CXXFunctionalCastExprClass:
131  case Stmt::CXXTypeidExprClass:
132  case Stmt::CXXUuidofExprClass:
133  case Stmt::CXXBoolLiteralExprClass:
134  case Stmt::CXXNullPtrLiteralExprClass:
135  case Stmt::CXXThisExprClass:
136  case Stmt::CXXThrowExprClass:
137  case Stmt::CXXDefaultArgExprClass:
138  case Stmt::CXXScalarValueInitExprClass:
139  case Stmt::CXXNewExprClass:
140  case Stmt::CXXDeleteExprClass:
141  case Stmt::CXXPseudoDestructorExprClass:
142  case Stmt::UnresolvedLookupExprClass:
143  case Stmt::UnaryTypeTraitExprClass:
144  case Stmt::DependentScopeDeclRefExprClass:
145  case Stmt::CXXBindTemporaryExprClass:
146  case Stmt::CXXExprWithTemporariesClass:
147  case Stmt::CXXUnresolvedConstructExprClass:
148  case Stmt::CXXDependentScopeMemberExprClass:
149  case Stmt::UnresolvedMemberExprClass:
150  case Stmt::CXXNoexceptExprClass:
151  case Stmt::ObjCStringLiteralClass:
152  case Stmt::ObjCEncodeExprClass:
153  case Stmt::ObjCSelectorExprClass:
154  case Stmt::ObjCProtocolExprClass:
155  case Stmt::ObjCImplicitSetterGetterRefExprClass:
156  case Stmt::ObjCSuperExprClass:
157  case Stmt::ObjCIsaExprClass:
158  case Stmt::ShuffleVectorExprClass:
159  case Stmt::BlockExprClass:
160    K = CXCursor_UnexposedExpr;
161    break;
162
163  case Stmt::DeclRefExprClass:
164  case Stmt::BlockDeclRefExprClass:
165    // FIXME: UnresolvedLookupExpr?
166    // FIXME: DependentScopeDeclRefExpr?
167    K = CXCursor_DeclRefExpr;
168    break;
169
170  case Stmt::MemberExprClass:
171  case Stmt::ObjCIvarRefExprClass:
172  case Stmt::ObjCPropertyRefExprClass:
173    // FIXME: UnresolvedMemberExpr?
174    // FIXME: CXXDependentScopeMemberExpr?
175    K = CXCursor_MemberRefExpr;
176    break;
177
178  case Stmt::CallExprClass:
179  case Stmt::CXXOperatorCallExprClass:
180  case Stmt::CXXMemberCallExprClass:
181  case Stmt::CXXConstructExprClass:
182  case Stmt::CXXTemporaryObjectExprClass:
183    // FIXME: CXXUnresolvedConstructExpr
184    // FIXME: ObjCImplicitSetterGetterRefExpr?
185    K = CXCursor_CallExpr;
186    break;
187
188  case Stmt::ObjCMessageExprClass:
189    K = CXCursor_ObjCMessageExpr;
190    break;
191  }
192
193  CXCursor C = { K, { Parent, S, TU } };
194  return C;
195}
196
197CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
198                                               SourceLocation Loc,
199                                               ASTUnit *TU) {
200  assert(Super && TU && "Invalid arguments!");
201  void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
202  CXCursor C = { CXCursor_ObjCSuperClassRef, { Super, RawLoc, TU } };
203  return C;
204}
205
206std::pair<ObjCInterfaceDecl *, SourceLocation>
207cxcursor::getCursorObjCSuperClassRef(CXCursor C) {
208  assert(C.kind == CXCursor_ObjCSuperClassRef);
209  return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]),
210           SourceLocation::getFromRawEncoding(
211                                      reinterpret_cast<uintptr_t>(C.data[1])));
212}
213
214CXCursor cxcursor::MakeCursorObjCProtocolRef(ObjCProtocolDecl *Super,
215                                             SourceLocation Loc,
216                                             ASTUnit *TU) {
217  assert(Super && TU && "Invalid arguments!");
218  void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
219  CXCursor C = { CXCursor_ObjCProtocolRef, { Super, RawLoc, TU } };
220  return C;
221}
222
223std::pair<ObjCProtocolDecl *, SourceLocation>
224cxcursor::getCursorObjCProtocolRef(CXCursor C) {
225  assert(C.kind == CXCursor_ObjCProtocolRef);
226  return std::make_pair(static_cast<ObjCProtocolDecl *>(C.data[0]),
227           SourceLocation::getFromRawEncoding(
228                                      reinterpret_cast<uintptr_t>(C.data[1])));
229}
230
231CXCursor cxcursor::MakeCursorObjCClassRef(ObjCInterfaceDecl *Class,
232                                          SourceLocation Loc,
233                                          ASTUnit *TU) {
234  // 'Class' can be null for invalid code.
235  if (!Class)
236    return MakeCXCursorInvalid(CXCursor_InvalidCode);
237  assert(TU && "Invalid arguments!");
238  void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
239  CXCursor C = { CXCursor_ObjCClassRef, { Class, RawLoc, TU } };
240  return C;
241}
242
243std::pair<ObjCInterfaceDecl *, SourceLocation>
244cxcursor::getCursorObjCClassRef(CXCursor C) {
245  assert(C.kind == CXCursor_ObjCClassRef);
246  return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]),
247           SourceLocation::getFromRawEncoding(
248                                      reinterpret_cast<uintptr_t>(C.data[1])));
249}
250
251CXCursor cxcursor::MakeCursorTypeRef(TypeDecl *Type, SourceLocation Loc,
252                                     ASTUnit *TU) {
253  assert(Type && TU && "Invalid arguments!");
254  void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
255  CXCursor C = { CXCursor_TypeRef, { Type, RawLoc, TU } };
256  return C;
257}
258
259std::pair<TypeDecl *, SourceLocation>
260cxcursor::getCursorTypeRef(CXCursor C) {
261  assert(C.kind == CXCursor_TypeRef);
262  return std::make_pair(static_cast<TypeDecl *>(C.data[0]),
263           SourceLocation::getFromRawEncoding(
264                                      reinterpret_cast<uintptr_t>(C.data[1])));
265}
266
267CXCursor cxcursor::MakeCursorTemplateRef(TemplateDecl *Template,
268                                         SourceLocation Loc, ASTUnit *TU) {
269  assert(Template && TU && "Invalid arguments!");
270  void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
271  CXCursor C = { CXCursor_TemplateRef, { Template, RawLoc, TU } };
272  return C;
273}
274
275std::pair<TemplateDecl *, SourceLocation>
276cxcursor::getCursorTemplateRef(CXCursor C) {
277  assert(C.kind == CXCursor_TemplateRef);
278  return std::make_pair(static_cast<TemplateDecl *>(C.data[0]),
279                        SourceLocation::getFromRawEncoding(
280                                       reinterpret_cast<uintptr_t>(C.data[1])));
281}
282
283CXCursor cxcursor::MakeCursorNamespaceRef(NamedDecl *NS, SourceLocation Loc,
284                                          ASTUnit *TU) {
285
286  assert(NS && (isa<NamespaceDecl>(NS) || isa<NamespaceAliasDecl>(NS)) && TU &&
287         "Invalid arguments!");
288  void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
289  CXCursor C = { CXCursor_NamespaceRef, { NS, RawLoc, TU } };
290  return C;
291}
292
293std::pair<NamedDecl *, SourceLocation>
294cxcursor::getCursorNamespaceRef(CXCursor C) {
295  assert(C.kind == CXCursor_NamespaceRef);
296  return std::make_pair(static_cast<NamedDecl *>(C.data[0]),
297                        SourceLocation::getFromRawEncoding(
298                                       reinterpret_cast<uintptr_t>(C.data[1])));
299}
300
301CXCursor cxcursor::MakeCursorMemberRef(FieldDecl *Field, SourceLocation Loc,
302                                       ASTUnit *TU) {
303
304  assert(Field && TU && "Invalid arguments!");
305  void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
306  CXCursor C = { CXCursor_MemberRef, { Field, RawLoc, TU } };
307  return C;
308}
309
310std::pair<FieldDecl *, SourceLocation>
311cxcursor::getCursorMemberRef(CXCursor C) {
312  assert(C.kind == CXCursor_MemberRef);
313  return std::make_pair(static_cast<FieldDecl *>(C.data[0]),
314                        SourceLocation::getFromRawEncoding(
315                                       reinterpret_cast<uintptr_t>(C.data[1])));
316}
317
318CXCursor cxcursor::MakeCursorCXXBaseSpecifier(CXXBaseSpecifier *B, ASTUnit *TU){
319  CXCursor C = { CXCursor_CXXBaseSpecifier, { B, 0, TU } };
320  return C;
321}
322
323CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) {
324  assert(C.kind == CXCursor_CXXBaseSpecifier);
325  return static_cast<CXXBaseSpecifier*>(C.data[0]);
326}
327
328CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range,
329                                                    ASTUnit *TU) {
330  CXCursor C = { CXCursor_PreprocessingDirective,
331                 { reinterpret_cast<void *>(Range.getBegin().getRawEncoding()),
332                   reinterpret_cast<void *>(Range.getEnd().getRawEncoding()),
333                   TU }
334               };
335  return C;
336}
337
338SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) {
339  assert(C.kind == CXCursor_PreprocessingDirective);
340  return SourceRange(SourceLocation::getFromRawEncoding(
341                                      reinterpret_cast<uintptr_t> (C.data[0])),
342                     SourceLocation::getFromRawEncoding(
343                                      reinterpret_cast<uintptr_t> (C.data[1])));
344}
345
346CXCursor cxcursor::MakeMacroDefinitionCursor(MacroDefinition *MI, ASTUnit *TU) {
347  CXCursor C = { CXCursor_MacroDefinition, { MI, 0, TU } };
348  return C;
349}
350
351MacroDefinition *cxcursor::getCursorMacroDefinition(CXCursor C) {
352  assert(C.kind == CXCursor_MacroDefinition);
353  return static_cast<MacroDefinition *>(C.data[0]);
354}
355
356CXCursor cxcursor::MakeMacroInstantiationCursor(MacroInstantiation *MI,
357                                                ASTUnit *TU) {
358  CXCursor C = { CXCursor_MacroInstantiation, { MI, 0, TU } };
359  return C;
360}
361
362MacroInstantiation *cxcursor::getCursorMacroInstantiation(CXCursor C) {
363  assert(C.kind == CXCursor_MacroInstantiation);
364  return static_cast<MacroInstantiation *>(C.data[0]);
365}
366
367CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc,
368                                      ASTUnit *TU) {
369
370  assert(Label && TU && "Invalid arguments!");
371  void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
372  CXCursor C = { CXCursor_LabelRef, { Label, RawLoc, TU } };
373  return C;
374}
375
376std::pair<LabelStmt*, SourceLocation>
377cxcursor::getCursorLabelRef(CXCursor C) {
378  assert(C.kind == CXCursor_LabelRef);
379  return std::make_pair(static_cast<LabelStmt *>(C.data[0]),
380                        SourceLocation::getFromRawEncoding(
381                                       reinterpret_cast<uintptr_t>(C.data[1])));
382}
383
384CXCursor cxcursor::MakeCursorOverloadedDeclRef(OverloadExpr *E,
385                                               ASTUnit *TU) {
386  assert(E && TU && "Invalid arguments!");
387  OverloadedDeclRefStorage Storage(E);
388  void *RawLoc = reinterpret_cast<void *>(E->getNameLoc().getRawEncoding());
389  CXCursor C = {
390                 CXCursor_OverloadedDeclRef,
391                 { Storage.getOpaqueValue(), RawLoc, TU }
392               };
393  return C;
394}
395
396CXCursor cxcursor::MakeCursorOverloadedDeclRef(Decl *D,
397                                               SourceLocation Loc,
398                                               ASTUnit *TU) {
399  assert(D && TU && "Invalid arguments!");
400  void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
401  OverloadedDeclRefStorage Storage(D);
402  CXCursor C = {
403    CXCursor_OverloadedDeclRef,
404    { Storage.getOpaqueValue(), RawLoc, TU }
405  };
406  return C;
407}
408
409CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name,
410                                               SourceLocation Loc,
411                                               ASTUnit *TU) {
412  assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!");
413  void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
414  OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate());
415  CXCursor C = {
416    CXCursor_OverloadedDeclRef,
417    { Storage.getOpaqueValue(), RawLoc, TU }
418  };
419  return C;
420}
421
422std::pair<cxcursor::OverloadedDeclRefStorage, SourceLocation>
423cxcursor::getCursorOverloadedDeclRef(CXCursor C) {
424  assert(C.kind == CXCursor_OverloadedDeclRef);
425  return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue(C.data[0]),
426                        SourceLocation::getFromRawEncoding(
427                                       reinterpret_cast<uintptr_t>(C.data[1])));
428}
429
430Decl *cxcursor::getCursorDecl(CXCursor Cursor) {
431  return (Decl *)Cursor.data[0];
432}
433
434Expr *cxcursor::getCursorExpr(CXCursor Cursor) {
435  return dyn_cast_or_null<Expr>(getCursorStmt(Cursor));
436}
437
438Stmt *cxcursor::getCursorStmt(CXCursor Cursor) {
439  if (Cursor.kind == CXCursor_ObjCSuperClassRef ||
440      Cursor.kind == CXCursor_ObjCProtocolRef ||
441      Cursor.kind == CXCursor_ObjCClassRef)
442    return 0;
443
444  return (Stmt *)Cursor.data[1];
445}
446
447Attr *cxcursor::getCursorAttr(CXCursor Cursor) {
448  return (Attr *)Cursor.data[1];
449}
450
451ASTContext &cxcursor::getCursorContext(CXCursor Cursor) {
452  return getCursorASTUnit(Cursor)->getASTContext();
453}
454
455ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) {
456  return static_cast<ASTUnit *>(Cursor.data[2]);
457}
458
459bool cxcursor::operator==(CXCursor X, CXCursor Y) {
460  return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] &&
461         X.data[2] == Y.data[2];
462}
463