 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
59.8% |
52 / 87 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
100.0% |
87 / 87 |
| |
|
Line Coverage: |
88.0% |
81 / 92 |
| |
 |
|
 |
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/DeclObjC.h"
20 : #include "clang/AST/Expr.h"
21 : #include "llvm/Support/ErrorHandling.h"
22 :
23 : using namespace clang;
24 :
25 13349: CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K) {
13349: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
13349: branch 3 taken
26 13349: assert(K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid);
27 13349: CXCursor C = { K, { 0, 0, 0 } };
28 : return C;
29 : }
30 :
31 1747: static CXCursorKind GetCursorKind(Decl *D) {
0: branch 0 not taken
1747: branch 1 taken
32 1747: assert(D && "Invalid arguments!");
23: branch 1 taken
11: branch 2 taken
16: branch 3 taken
345: branch 4 taken
93: branch 5 taken
0: branch 6 not taken
22: branch 7 taken
0: branch 8 not taken
0: branch 9 not taken
189: branch 10 taken
8: branch 11 taken
139: branch 12 taken
0: branch 13 not taken
80: branch 14 taken
611: branch 15 taken
53: branch 16 taken
133: branch 17 taken
24: branch 18 taken
33 1747: switch (D->getKind()) {
34 23: case Decl::Enum: return CXCursor_EnumDecl;
35 11: case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
36 16: case Decl::Field: return CXCursor_FieldDecl;
37 : case Decl::Function:
38 345: return CXCursor_FunctionDecl;
39 93: case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
40 0: case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
41 : case Decl::ObjCClass:
42 : // FIXME
43 22: return CXCursor_UnexposedDecl;
44 : case Decl::ObjCForwardProtocol:
45 : // FIXME
46 0: return CXCursor_UnexposedDecl;
47 0: case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
48 189: case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl;
49 8: case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
50 : case Decl::ObjCMethod:
51 : return cast<ObjCMethodDecl>(D)->isInstanceMethod()
128: branch 2 taken
11: branch 3 taken
52 139: ? CXCursor_ObjCInstanceMethodDecl : CXCursor_ObjCClassMethodDecl;
53 0: case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
54 80: case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl;
55 611: case Decl::ParmVar: return CXCursor_ParmDecl;
56 53: case Decl::Typedef: return CXCursor_TypedefDecl;
57 133: case Decl::Var: return CXCursor_VarDecl;
58 : default:
20: branch 1 taken
4: branch 2 taken
59 24: if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
20: branch 1 taken
0: branch 2 not taken
0: branch 3 not taken
0: branch 4 not taken
0: branch 5 not taken
60 20: switch (TD->getTagKind()) {
61 20: case TagDecl::TK_struct: return CXCursor_StructDecl;
62 0: case TagDecl::TK_class: return CXCursor_ClassDecl;
63 0: case TagDecl::TK_union: return CXCursor_UnionDecl;
64 0: case TagDecl::TK_enum: return CXCursor_EnumDecl;
65 : }
66 : }
67 :
68 4: return CXCursor_UnexposedDecl;
69 : }
70 :
71 : llvm_unreachable("Invalid Decl");
72 : return CXCursor_NotImplemented;
73 : }
74 :
75 1747: CXCursor cxcursor::MakeCXCursor(Decl *D, ASTUnit *TU) {
1747: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
1747: branch 3 taken
76 1747: assert(D && TU && "Invalid arguments!");
77 1747: CXCursor C = { GetCursorKind(D), { D, 0, TU } };
78 : return C;
79 : }
80 :
81 2185: CXCursor cxcursor::MakeCXCursor(Stmt *S, Decl *Parent, ASTUnit *TU) {
2185: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
2185: branch 3 taken
82 2185: assert(S && TU && "Invalid arguments!");
83 2185: CXCursorKind K = CXCursor_NotImplemented;
84 :
0: branch 1 not taken
1068: branch 2 taken
328: branch 3 taken
172: branch 4 taken
0: branch 5 not taken
182: branch 6 taken
435: branch 7 taken
0: branch 8 not taken
85 2185: switch (S->getStmtClass()) {
86 : case Stmt::NoStmtClass:
87 0: break;
88 :
89 : case Stmt::NullStmtClass:
90 : case Stmt::CompoundStmtClass:
91 : case Stmt::CaseStmtClass:
92 : case Stmt::DefaultStmtClass:
93 : case Stmt::LabelStmtClass:
94 : case Stmt::IfStmtClass:
95 : case Stmt::SwitchStmtClass:
96 : case Stmt::WhileStmtClass:
97 : case Stmt::DoStmtClass:
98 : case Stmt::ForStmtClass:
99 : case Stmt::GotoStmtClass:
100 : case Stmt::IndirectGotoStmtClass:
101 : case Stmt::ContinueStmtClass:
102 : case Stmt::BreakStmtClass:
103 : case Stmt::ReturnStmtClass:
104 : case Stmt::DeclStmtClass:
105 : case Stmt::SwitchCaseClass:
106 : case Stmt::AsmStmtClass:
107 : case Stmt::ObjCAtTryStmtClass:
108 : case Stmt::ObjCAtCatchStmtClass:
109 : case Stmt::ObjCAtFinallyStmtClass:
110 : case Stmt::ObjCAtThrowStmtClass:
111 : case Stmt::ObjCAtSynchronizedStmtClass:
112 : case Stmt::ObjCForCollectionStmtClass:
113 : case Stmt::CXXCatchStmtClass:
114 : case Stmt::CXXTryStmtClass:
115 1068: K = CXCursor_UnexposedStmt;
116 1068: break;
117 :
118 : case Stmt::PredefinedExprClass:
119 : case Stmt::IntegerLiteralClass:
120 : case Stmt::FloatingLiteralClass:
121 : case Stmt::ImaginaryLiteralClass:
122 : case Stmt::StringLiteralClass:
123 : case Stmt::CharacterLiteralClass:
124 : case Stmt::ParenExprClass:
125 : case Stmt::UnaryOperatorClass:
126 : case Stmt::SizeOfAlignOfExprClass:
127 : case Stmt::ArraySubscriptExprClass:
128 : case Stmt::BinaryOperatorClass:
129 : case Stmt::CompoundAssignOperatorClass:
130 : case Stmt::ConditionalOperatorClass:
131 : case Stmt::ImplicitCastExprClass:
132 : case Stmt::CStyleCastExprClass:
133 : case Stmt::CompoundLiteralExprClass:
134 : case Stmt::ExtVectorElementExprClass:
135 : case Stmt::InitListExprClass:
136 : case Stmt::DesignatedInitExprClass:
137 : case Stmt::ImplicitValueInitExprClass:
138 : case Stmt::ParenListExprClass:
139 : case Stmt::VAArgExprClass:
140 : case Stmt::AddrLabelExprClass:
141 : case Stmt::StmtExprClass:
142 : case Stmt::TypesCompatibleExprClass:
143 : case Stmt::ChooseExprClass:
144 : case Stmt::GNUNullExprClass:
145 : case Stmt::CXXNamedCastExprClass:
146 : case Stmt::CXXStaticCastExprClass:
147 : case Stmt::CXXDynamicCastExprClass:
148 : case Stmt::CXXReinterpretCastExprClass:
149 : case Stmt::CXXConstCastExprClass:
150 : case Stmt::CXXFunctionalCastExprClass:
151 : case Stmt::CXXTypeidExprClass:
152 : case Stmt::CXXBoolLiteralExprClass:
153 : case Stmt::CXXNullPtrLiteralExprClass:
154 : case Stmt::CXXThisExprClass:
155 : case Stmt::CXXThrowExprClass:
156 : case Stmt::CXXDefaultArgExprClass:
157 : case Stmt::CXXZeroInitValueExprClass:
158 : case Stmt::CXXNewExprClass:
159 : case Stmt::CXXDeleteExprClass:
160 : case Stmt::CXXPseudoDestructorExprClass:
161 : case Stmt::UnresolvedLookupExprClass:
162 : case Stmt::UnaryTypeTraitExprClass:
163 : case Stmt::DependentScopeDeclRefExprClass:
164 : case Stmt::CXXBindTemporaryExprClass:
165 : case Stmt::CXXBindReferenceExprClass:
166 : case Stmt::CXXExprWithTemporariesClass:
167 : case Stmt::CXXUnresolvedConstructExprClass:
168 : case Stmt::CXXDependentScopeMemberExprClass:
169 : case Stmt::UnresolvedMemberExprClass:
170 : case Stmt::ObjCStringLiteralClass:
171 : case Stmt::ObjCEncodeExprClass:
172 : case Stmt::ObjCSelectorExprClass:
173 : case Stmt::ObjCProtocolExprClass:
174 : case Stmt::ObjCImplicitSetterGetterRefExprClass:
175 : case Stmt::ObjCSuperExprClass:
176 : case Stmt::ObjCIsaExprClass:
177 : case Stmt::ShuffleVectorExprClass:
178 : case Stmt::BlockExprClass:
179 328: K = CXCursor_UnexposedExpr;
180 328: break;
181 : case Stmt::DeclRefExprClass:
182 : case Stmt::BlockDeclRefExprClass:
183 : // FIXME: UnresolvedLookupExpr?
184 : // FIXME: DependentScopeDeclRefExpr?
185 172: K = CXCursor_DeclRefExpr;
186 172: break;
187 :
188 : case Stmt::MemberExprClass:
189 : case Stmt::ObjCIvarRefExprClass:
190 : case Stmt::ObjCPropertyRefExprClass:
191 : // FIXME: UnresolvedMemberExpr?
192 : // FIXME: CXXDependentScopeMemberExpr?
193 0: K = CXCursor_MemberRefExpr;
194 0: break;
195 :
196 : case Stmt::CallExprClass:
197 : case Stmt::CXXOperatorCallExprClass:
198 : case Stmt::CXXMemberCallExprClass:
199 : case Stmt::CXXConstructExprClass:
200 : case Stmt::CXXTemporaryObjectExprClass:
201 : // FIXME: CXXUnresolvedConstructExpr
202 : // FIXME: ObjCImplicitSetterGetterRefExpr?
203 182: K = CXCursor_CallExpr;
204 182: break;
205 :
206 : case Stmt::ObjCMessageExprClass:
207 435: K = CXCursor_ObjCMessageExpr;
208 : break;
209 : }
210 :
211 2185: CXCursor C = { K, { Parent, S, TU } };
212 : return C;
213 : }
214 :
215 : CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
216 : SourceLocation Loc,
217 109: ASTUnit *TU) {
109: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
109: branch 3 taken
218 109: assert(Super && TU && "Invalid arguments!");
219 109: void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
220 109: CXCursor C = { CXCursor_ObjCSuperClassRef, { Super, RawLoc, TU } };
221 : return C;
222 : }
223 :
224 : std::pair<ObjCInterfaceDecl *, SourceLocation>
225 121: cxcursor::getCursorObjCSuperClassRef(CXCursor C) {
0: branch 0 not taken
121: branch 1 taken
226 121: assert(C.kind == CXCursor_ObjCSuperClassRef);
227 : return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]),
228 : SourceLocation::getFromRawEncoding(
229 121: reinterpret_cast<uintptr_t>(C.data[1])));
230 : }
231 :
232 : CXCursor cxcursor::MakeCursorObjCProtocolRef(ObjCProtocolDecl *Super,
233 : SourceLocation Loc,
234 155: ASTUnit *TU) {
155: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
155: branch 3 taken
235 155: assert(Super && TU && "Invalid arguments!");
236 155: void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
237 155: CXCursor C = { CXCursor_ObjCProtocolRef, { Super, RawLoc, TU } };
238 : return C;
239 : }
240 :
241 : std::pair<ObjCProtocolDecl *, SourceLocation>
242 179: cxcursor::getCursorObjCProtocolRef(CXCursor C) {
0: branch 0 not taken
179: branch 1 taken
243 179: assert(C.kind == CXCursor_ObjCProtocolRef);
244 : return std::make_pair(static_cast<ObjCProtocolDecl *>(C.data[0]),
245 : SourceLocation::getFromRawEncoding(
246 179: reinterpret_cast<uintptr_t>(C.data[1])));
247 : }
248 :
249 : CXCursor cxcursor::MakeCursorObjCClassRef(ObjCInterfaceDecl *Class,
250 : SourceLocation Loc,
251 145: ASTUnit *TU) {
145: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
145: branch 3 taken
252 145: assert(Class && TU && "Invalid arguments!");
253 145: void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
254 145: CXCursor C = { CXCursor_ObjCClassRef, { Class, RawLoc, TU } };
255 : return C;
256 : }
257 :
258 : std::pair<ObjCInterfaceDecl *, SourceLocation>
259 181: cxcursor::getCursorObjCClassRef(CXCursor C) {
0: branch 0 not taken
181: branch 1 taken
260 181: assert(C.kind == CXCursor_ObjCClassRef);
261 : return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]),
262 : SourceLocation::getFromRawEncoding(
263 181: reinterpret_cast<uintptr_t>(C.data[1])));
264 : }
265 :
266 : CXCursor cxcursor::MakeCursorTypeRef(TypeDecl *Type, SourceLocation Loc,
267 80: ASTUnit *TU) {
80: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
80: branch 3 taken
268 80: assert(Type && TU && "Invalid arguments!");
269 80: void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
270 80: CXCursor C = { CXCursor_TypeRef, { Type, RawLoc, TU } };
271 : return C;
272 : }
273 :
274 : std::pair<TypeDecl *, SourceLocation>
275 193: cxcursor::getCursorTypeRef(CXCursor C) {
0: branch 0 not taken
193: branch 1 taken
276 193: assert(C.kind == CXCursor_TypeRef);
277 : return std::make_pair(static_cast<TypeDecl *>(C.data[0]),
278 : SourceLocation::getFromRawEncoding(
279 193: reinterpret_cast<uintptr_t>(C.data[1])));
280 : }
281 :
282 7148: Decl *cxcursor::getCursorDecl(CXCursor Cursor) {
283 7148: return (Decl *)Cursor.data[0];
284 : }
285 :
286 1706: Expr *cxcursor::getCursorExpr(CXCursor Cursor) {
287 1706: return dyn_cast_or_null<Expr>(getCursorStmt(Cursor));
288 : }
289 :
290 3104: Stmt *cxcursor::getCursorStmt(CXCursor Cursor) {
3104: branch 0 taken
0: branch 1 not taken
3104: branch 2 taken
0: branch 3 not taken
0: branch 4 not taken
3104: branch 5 taken
291 3104: if (Cursor.kind == CXCursor_ObjCSuperClassRef ||
292 : Cursor.kind == CXCursor_ObjCProtocolRef ||
293 : Cursor.kind == CXCursor_ObjCClassRef)
294 0: return 0;
295 :
296 3104: return (Stmt *)Cursor.data[1];
297 : }
298 :
299 2345: ASTContext &cxcursor::getCursorContext(CXCursor Cursor) {
300 2345: return getCursorASTUnit(Cursor)->getASTContext();
301 : }
302 :
303 15723: ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) {
304 15723: return static_cast<ASTUnit *>(Cursor.data[2]);
305 : }
306 :
307 13356: bool cxcursor::operator==(CXCursor X, CXCursor Y) {
308 : return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] &&
12893: branch 0 taken
463: branch 1 taken
12893: branch 2 taken
0: branch 3 not taken
12887: branch 4 taken
6: branch 5 taken
12887: branch 6 taken
0: branch 7 not taken
309 13356: X.data[2] == Y.data[2];
310 : }
Generated: 2010-02-10 01:31 by zcov