 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
61.1% |
58 / 95 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
81.1% |
77 / 95 |
| |
|
Line Coverage: |
67.8% |
223 / 329 |
| |
 |
|
 |
1 : //===--- StmtDumper.cpp - Dumping implementation for Stmt ASTs ------------===//
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 implements the Stmt::dump/Stmt::print methods, which dump out the
11 : // AST in a form that exposes type details and other fields.
12 : //
13 : //===----------------------------------------------------------------------===//
14 :
15 : #include "clang/AST/StmtVisitor.h"
16 : #include "clang/AST/DeclObjC.h"
17 : #include "clang/AST/DeclCXX.h"
18 : #include "clang/AST/PrettyPrinter.h"
19 : #include "clang/Basic/SourceManager.h"
20 : #include "llvm/Support/raw_ostream.h"
21 : using namespace clang;
22 :
23 : //===----------------------------------------------------------------------===//
24 : // StmtDumper Visitor
25 : //===----------------------------------------------------------------------===//
26 :
27 : namespace {
28 : class StmtDumper : public StmtVisitor<StmtDumper> {
29 : SourceManager *SM;
30 : llvm::raw_ostream &OS;
31 : unsigned IndentLevel;
32 :
33 : /// MaxDepth - When doing a normal dump (not dumpAll) we only want to dump
34 : /// the first few levels of an AST. This keeps track of how many ast levels
35 : /// are left.
36 : unsigned MaxDepth;
37 :
38 : /// LastLocFilename/LastLocLine - Keep track of the last location we print
39 : /// out so that we can print out deltas from then on out.
40 : const char *LastLocFilename;
41 : unsigned LastLocLine;
42 :
43 : public:
44 24: StmtDumper(SourceManager *sm, llvm::raw_ostream &os, unsigned maxDepth)
45 24: : SM(sm), OS(os), IndentLevel(0-1), MaxDepth(maxDepth) {
46 24: LastLocFilename = "";
47 24: LastLocLine = ~0U;
48 24: }
49 :
50 360: void DumpSubTree(Stmt *S) {
51 : // Prune the recursion if not using dump all.
360: branch 0 taken
0: branch 1 not taken
52 360: if (MaxDepth == 0) return;
53 :
54 360: ++IndentLevel;
354: branch 0 taken
6: branch 1 taken
55 360: if (S) {
67: branch 1 taken
287: branch 2 taken
56 354: if (DeclStmt* DS = dyn_cast<DeclStmt>(S))
57 67: VisitDeclStmt(DS);
58 : else {
59 287: Visit(S);
60 :
61 : // Print out children.
62 287: Stmt::child_iterator CI = S->child_begin(), CE = S->child_end();
149: branch 1 taken
138: branch 2 taken
63 287: if (CI != CE) {
288: branch 1 taken
149: branch 2 taken
64 586: while (CI != CE) {
65 288: OS << '\n';
66 288: DumpSubTree(*CI++);
67 : }
68 : }
69 287: OS << ')';
70 : }
71 : } else {
72 6: Indent();
73 6: OS << "<<<NULL>>>";
74 : }
75 360: --IndentLevel;
76 : }
77 :
78 : void DumpDeclarator(Decl *D);
79 :
80 438: void Indent() const {
1127: branch 0 taken
438: branch 1 taken
81 1565: for (int i = 0, e = IndentLevel; i < e; ++i)
82 1127: OS << " ";
83 438: }
84 :
85 232: void DumpType(QualType T) {
86 232: OS << "'" << T.getAsString() << "'";
87 :
232: branch 1 taken
0: branch 2 not taken
88 232: if (!T.isNull()) {
89 : // If the type is sugared, also dump a (shallow) desugared type.
90 232: QualType Simplified = T.getDesugaredType();
31: branch 1 taken
201: branch 2 taken
91 232: if (Simplified != T)
92 31: OS << ":'" << Simplified.getAsString() << "'";
93 : }
94 232: }
95 354: void DumpStmt(const Stmt *Node) {
96 354: Indent();
97 : OS << "(" << Node->getStmtClassName()
98 354: << " " << (void*)Node;
99 354: DumpSourceRange(Node);
100 354: }
101 223: void DumpExpr(const Expr *Node) {
102 223: DumpStmt(Node);
103 223: OS << ' ';
104 223: DumpType(Node->getType());
105 223: }
106 : void DumpSourceRange(const Stmt *Node);
107 : void DumpLocation(SourceLocation Loc);
108 :
109 : // Stmts.
110 : void VisitStmt(Stmt *Node);
111 : void VisitDeclStmt(DeclStmt *Node);
112 : void VisitLabelStmt(LabelStmt *Node);
113 : void VisitGotoStmt(GotoStmt *Node);
114 :
115 : // Exprs
116 : void VisitExpr(Expr *Node);
117 : void VisitCastExpr(CastExpr *Node);
118 : void VisitImplicitCastExpr(ImplicitCastExpr *Node);
119 : void VisitDeclRefExpr(DeclRefExpr *Node);
120 : void VisitPredefinedExpr(PredefinedExpr *Node);
121 : void VisitCharacterLiteral(CharacterLiteral *Node);
122 : void VisitIntegerLiteral(IntegerLiteral *Node);
123 : void VisitFloatingLiteral(FloatingLiteral *Node);
124 : void VisitStringLiteral(StringLiteral *Str);
125 : void VisitUnaryOperator(UnaryOperator *Node);
126 : void VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *Node);
127 : void VisitMemberExpr(MemberExpr *Node);
128 : void VisitExtVectorElementExpr(ExtVectorElementExpr *Node);
129 : void VisitBinaryOperator(BinaryOperator *Node);
130 : void VisitCompoundAssignOperator(CompoundAssignOperator *Node);
131 : void VisitAddrLabelExpr(AddrLabelExpr *Node);
132 : void VisitTypesCompatibleExpr(TypesCompatibleExpr *Node);
133 :
134 : // C++
135 : void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
136 : void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node);
137 : void VisitCXXThisExpr(CXXThisExpr *Node);
138 : void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node);
139 : void VisitCXXConstructExpr(CXXConstructExpr *Node);
140 : void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node);
141 : void VisitCXXExprWithTemporaries(CXXExprWithTemporaries *Node);
142 : void VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node);
143 : void DumpCXXTemporary(CXXTemporary *Temporary);
144 :
145 : // ObjC
146 : void VisitObjCEncodeExpr(ObjCEncodeExpr *Node);
147 : void VisitObjCMessageExpr(ObjCMessageExpr* Node);
148 : void VisitObjCSelectorExpr(ObjCSelectorExpr *Node);
149 : void VisitObjCProtocolExpr(ObjCProtocolExpr *Node);
150 : void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node);
151 : void VisitObjCImplicitSetterGetterRefExpr(
152 : ObjCImplicitSetterGetterRefExpr *Node);
153 : void VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node);
154 : void VisitObjCSuperExpr(ObjCSuperExpr *Node);
155 : };
156 : }
157 :
158 : //===----------------------------------------------------------------------===//
159 : // Utilities
160 : //===----------------------------------------------------------------------===//
161 :
162 553: void StmtDumper::DumpLocation(SourceLocation Loc) {
163 553: SourceLocation SpellingLoc = SM->getSpellingLoc(Loc);
164 :
6: branch 1 taken
547: branch 2 taken
165 553: if (SpellingLoc.isInvalid()) {
166 6: OS << "<invalid sloc>";
167 6: return;
168 : }
169 :
170 : // The general format we print out is filename:line:col, but we drop pieces
171 : // that haven't changed since the last loc printed.
172 547: PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc);
173 :
28: branch 2 taken
519: branch 3 taken
174 547: if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) {
175 : OS << PLoc.getFilename() << ':' << PLoc.getLine()
176 28: << ':' << PLoc.getColumn();
177 28: LastLocFilename = PLoc.getFilename();
178 28: LastLocLine = PLoc.getLine();
165: branch 1 taken
354: branch 2 taken
179 519: } else if (PLoc.getLine() != LastLocLine) {
180 : OS << "line" << ':' << PLoc.getLine()
181 165: << ':' << PLoc.getColumn();
182 165: LastLocLine = PLoc.getLine();
183 : } else {
184 354: OS << "col" << ':' << PLoc.getColumn();
185 : }
186 : }
187 :
188 354: void StmtDumper::DumpSourceRange(const Stmt *Node) {
189 : // Can't translate locations if a SourceManager isn't available.
354: branch 0 taken
0: branch 1 not taken
190 354: if (SM == 0) return;
191 :
192 : // TODO: If the parent expression is available, we can print a delta vs its
193 : // location.
194 354: SourceRange R = Node->getSourceRange();
195 :
196 354: OS << " <";
197 354: DumpLocation(R.getBegin());
199: branch 3 taken
155: branch 4 taken
198 354: if (R.getBegin() != R.getEnd()) {
199 199: OS << ", ";
200 199: DumpLocation(R.getEnd());
201 : }
202 354: OS << ">";
203 :
204 : // <t2.c:123:421[blah], t2.c:412:321>
205 :
206 : }
207 :
208 :
209 : //===----------------------------------------------------------------------===//
210 : // Stmt printing methods.
211 : //===----------------------------------------------------------------------===//
212 :
213 62: void StmtDumper::VisitStmt(Stmt *Node) {
214 62: DumpStmt(Node);
215 62: }
216 :
217 78: void StmtDumper::DumpDeclarator(Decl *D) {
218 : // FIXME: Need to complete/beautify this... this code simply shows the
219 : // nodes are where they need to be.
0: branch 1 not taken
78: branch 2 taken
220 78: if (TypedefDecl *localType = dyn_cast<TypedefDecl>(D)) {
221 : OS << "\"typedef " << localType->getUnderlyingType().getAsString()
222 0: << " " << localType->getNameAsString() << "\"";
74: branch 1 taken
4: branch 2 taken
223 78: } else if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
224 74: OS << "\"";
225 : // Emit storage class for vardecls.
71: branch 1 taken
3: branch 2 taken
226 74: if (VarDecl *V = dyn_cast<VarDecl>(VD)) {
0: branch 1 not taken
71: branch 2 taken
227 71: if (V->getStorageClass() != VarDecl::None)
228 : OS << VarDecl::getStorageClassSpecifierString(V->getStorageClass())
229 0: << " ";
230 : }
231 :
232 74: std::string Name = VD->getNameAsString();
233 : VD->getType().getAsStringInternal(Name,
234 74: PrintingPolicy(VD->getASTContext().getLangOptions()));
235 74: OS << Name;
236 :
237 : // If this is a vardecl with an initializer, emit it.
71: branch 1 taken
3: branch 2 taken
238 74: if (VarDecl *V = dyn_cast<VarDecl>(VD)) {
48: branch 1 taken
23: branch 2 taken
239 71: if (V->getInit()) {
240 48: OS << " =\n";
241 48: DumpSubTree(V->getInit());
242 : }
243 : }
244 74: OS << '"';
4: branch 1 taken
0: branch 2 not taken
245 4: } else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
246 : // print a free standing tag decl (e.g. "struct x;").
247 : const char *tagname;
2: branch 1 taken
2: branch 2 taken
248 4: if (const IdentifierInfo *II = TD->getIdentifier())
249 2: tagname = II->getNameStart();
250 : else
251 2: tagname = "<anonymous>";
252 4: OS << '"' << TD->getKindName() << ' ' << tagname << ";\"";
253 : // FIXME: print tag bodies.
0: branch 1 not taken
0: branch 2 not taken
254 0: } else if (UsingDirectiveDecl *UD = dyn_cast<UsingDirectiveDecl>(D)) {
255 : // print using-directive decl (e.g. "using namespace x;")
256 : const char *ns;
0: branch 2 not taken
0: branch 3 not taken
257 0: if (const IdentifierInfo *II = UD->getNominatedNamespace()->getIdentifier())
258 0: ns = II->getNameStart();
259 : else
260 0: ns = "<anonymous>";
261 0: OS << '"' << UD->getDeclKindName() << ns << ";\"";
262 : } else {
263 0: assert(0 && "Unexpected decl");
264 : }
265 78: }
266 :
267 67: void StmtDumper::VisitDeclStmt(DeclStmt *Node) {
268 67: DumpStmt(Node);
269 67: OS << "\n";
78: branch 2 taken
67: branch 3 taken
270 145: for (DeclStmt::decl_iterator DI = Node->decl_begin(), DE = Node->decl_end();
271 : DI != DE; ++DI) {
272 78: Decl* D = *DI;
273 78: ++IndentLevel;
274 78: Indent();
275 78: OS << (void*) D << " ";
276 78: DumpDeclarator(D);
11: branch 0 taken
67: branch 1 taken
277 78: if (DI+1 != DE)
278 11: OS << "\n";
279 78: --IndentLevel;
280 : }
281 67: }
282 :
283 1: void StmtDumper::VisitLabelStmt(LabelStmt *Node) {
284 1: DumpStmt(Node);
285 1: OS << " '" << Node->getName() << "'";
286 1: }
287 :
288 1: void StmtDumper::VisitGotoStmt(GotoStmt *Node) {
289 1: DumpStmt(Node);
290 : OS << " '" << Node->getLabel()->getName()
291 1: << "':" << (void*)Node->getLabel();
292 1: }
293 :
294 : //===----------------------------------------------------------------------===//
295 : // Expr printing methods.
296 : //===----------------------------------------------------------------------===//
297 :
298 28: void StmtDumper::VisitExpr(Expr *Node) {
299 28: DumpExpr(Node);
300 28: }
301 :
302 44: void StmtDumper::VisitCastExpr(CastExpr *Node) {
303 44: DumpExpr(Node);
304 44: OS << " <" << Node->getCastKindName() << ">";
305 44: }
306 :
307 41: void StmtDumper::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
308 41: VisitCastExpr(Node);
5: branch 1 taken
36: branch 2 taken
309 41: if (Node->isLvalueCast())
310 5: OS << " lvalue";
311 41: }
312 :
313 70: void StmtDumper::VisitDeclRefExpr(DeclRefExpr *Node) {
314 70: DumpExpr(Node);
315 :
316 70: OS << " ";
0: branch 2 not taken
7: branch 3 taken
50: branch 4 taken
13: branch 5 taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 11 not taken
0: branch 12 not taken
317 70: switch (Node->getDecl()->getKind()) {
318 0: default: OS << "Decl"; break;
319 7: case Decl::Function: OS << "FunctionDecl"; break;
320 50: case Decl::Var: OS << "Var"; break;
321 13: case Decl::ParmVar: OS << "ParmVar"; break;
322 0: case Decl::EnumConstant: OS << "EnumConstant"; break;
323 0: case Decl::Typedef: OS << "Typedef"; break;
324 0: case Decl::Record: OS << "Record"; break;
325 0: case Decl::Enum: OS << "Enum"; break;
326 0: case Decl::CXXRecord: OS << "CXXRecord"; break;
327 0: case Decl::ObjCInterface: OS << "ObjCInterface"; break;
328 0: case Decl::ObjCClass: OS << "ObjCClass"; break;
329 : }
330 :
331 : OS << "='" << Node->getDecl()->getNameAsString()
332 70: << "' " << (void*)Node->getDecl();
333 70: }
334 :
335 0: void StmtDumper::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) {
336 0: DumpExpr(Node);
337 0: OS << " (";
0: branch 1 not taken
0: branch 2 not taken
338 0: if (!Node->requiresADL()) OS << "no ";
339 0: OS << "ADL) = '" << Node->getName().getAsString() << "'";
340 :
341 : UnresolvedLookupExpr::decls_iterator
342 0: I = Node->decls_begin(), E = Node->decls_end();
0: branch 1 not taken
0: branch 2 not taken
343 0: if (I == E) OS << " empty";
0: branch 2 not taken
0: branch 3 not taken
344 0: for (; I != E; ++I)
345 0: OS << " " << (void*) *I;
346 0: }
347 :
348 0: void StmtDumper::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
349 0: DumpExpr(Node);
350 :
351 : OS << " " << Node->getDecl()->getDeclKindName()
352 : << "Decl='" << Node->getDecl()->getNameAsString()
353 0: << "' " << (void*)Node->getDecl();
0: branch 1 not taken
0: branch 2 not taken
354 0: if (Node->isFreeIvar())
355 0: OS << " isFreeIvar";
356 0: }
357 :
358 7: void StmtDumper::VisitPredefinedExpr(PredefinedExpr *Node) {
359 7: DumpExpr(Node);
0: branch 1 not taken
2: branch 2 taken
3: branch 3 taken
2: branch 4 taken
360 7: switch (Node->getIdentType()) {
361 0: default: assert(0 && "unknown case");
362 2: case PredefinedExpr::Func: OS << " __func__"; break;
363 3: case PredefinedExpr::Function: OS << " __FUNCTION__"; break;
364 2: case PredefinedExpr::PrettyFunction: OS << " __PRETTY_FUNCTION__";break;
365 : }
366 7: }
367 :
368 1: void StmtDumper::VisitCharacterLiteral(CharacterLiteral *Node) {
369 1: DumpExpr(Node);
370 1: OS << Node->getValue();
371 1: }
372 :
373 24: void StmtDumper::VisitIntegerLiteral(IntegerLiteral *Node) {
374 24: DumpExpr(Node);
375 :
376 24: bool isSigned = Node->getType()->isSignedIntegerType();
377 24: OS << " " << Node->getValue().toString(10, isSigned);
378 24: }
379 1: void StmtDumper::VisitFloatingLiteral(FloatingLiteral *Node) {
380 1: DumpExpr(Node);
381 1: OS << " " << Node->getValueAsApproximateDouble();
382 1: }
383 :
384 2: void StmtDumper::VisitStringLiteral(StringLiteral *Str) {
385 2: DumpExpr(Str);
386 : // FIXME: this doesn't print wstrings right.
387 2: OS << " ";
0: branch 1 not taken
2: branch 2 taken
388 2: if (Str->isWide())
389 0: OS << "L";
390 2: OS << '"';
391 : OS.write_escaped(llvm::StringRef(Str->getStrData(),
392 2: Str->getByteLength()));
393 2: OS << '"';
394 2: }
395 :
396 18: void StmtDumper::VisitUnaryOperator(UnaryOperator *Node) {
397 18: DumpExpr(Node);
398 : OS << " " << (Node->isPostfix() ? "postfix" : "prefix")
1: branch 3 taken
17: branch 4 taken
399 18: << " '" << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
400 18: }
401 1: void StmtDumper::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *Node) {
402 1: DumpExpr(Node);
1: branch 1 taken
0: branch 2 not taken
403 1: OS << " " << (Node->isSizeOf() ? "sizeof" : "alignof") << " ";
1: branch 1 taken
0: branch 2 not taken
404 1: if (Node->isArgumentType())
405 1: DumpType(Node->getArgumentType());
406 1: }
407 :
408 5: void StmtDumper::VisitMemberExpr(MemberExpr *Node) {
409 5: DumpExpr(Node);
410 : OS << " " << (Node->isArrow() ? "->" : ".")
411 : << Node->getMemberDecl()->getNameAsString() << " "
1: branch 4 taken
4: branch 5 taken
412 5: << (void*)Node->getMemberDecl();
413 5: }
414 4: void StmtDumper::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
415 4: DumpExpr(Node);
416 4: OS << " " << Node->getAccessor().getNameStart();
417 4: }
418 7: void StmtDumper::VisitBinaryOperator(BinaryOperator *Node) {
419 7: DumpExpr(Node);
420 7: OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
421 7: }
422 2: void StmtDumper::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
423 2: DumpExpr(Node);
424 : OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
425 2: << "' ComputeLHSTy=";
426 2: DumpType(Node->getComputationLHSType());
427 2: OS << " ComputeResultTy=";
428 2: DumpType(Node->getComputationResultType());
429 2: }
430 :
431 : // GNU extensions.
432 :
433 1: void StmtDumper::VisitAddrLabelExpr(AddrLabelExpr *Node) {
434 1: DumpExpr(Node);
435 : OS << " " << Node->getLabel()->getName()
436 1: << " " << (void*)Node->getLabel();
437 1: }
438 :
439 1: void StmtDumper::VisitTypesCompatibleExpr(TypesCompatibleExpr *Node) {
440 1: DumpExpr(Node);
441 1: OS << " ";
442 1: DumpType(Node->getArgType1());
443 1: OS << " ";
444 1: DumpType(Node->getArgType2());
445 1: }
446 :
447 : //===----------------------------------------------------------------------===//
448 : // C++ Expressions
449 : //===----------------------------------------------------------------------===//
450 :
451 0: void StmtDumper::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
452 0: DumpExpr(Node);
453 : OS << " " << Node->getCastName()
454 : << "<" << Node->getTypeAsWritten().getAsString() << ">"
455 0: << " <" << Node->getCastKindName() << ">";
456 0: }
457 :
458 0: void StmtDumper::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
459 0: DumpExpr(Node);
0: branch 1 not taken
0: branch 2 not taken
460 0: OS << " " << (Node->getValue() ? "true" : "false");
461 0: }
462 :
463 0: void StmtDumper::VisitCXXThisExpr(CXXThisExpr *Node) {
464 0: DumpExpr(Node);
465 0: OS << " this";
466 0: }
467 :
468 0: void StmtDumper::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
469 0: DumpExpr(Node);
470 0: OS << " functional cast to " << Node->getTypeAsWritten().getAsString();
471 0: }
472 :
473 2: void StmtDumper::VisitCXXConstructExpr(CXXConstructExpr *Node) {
474 2: DumpExpr(Node);
475 2: CXXConstructorDecl *Ctor = Node->getConstructor();
476 2: DumpType(Ctor->getType());
0: branch 1 not taken
2: branch 2 taken
477 2: if (Node->isElidable())
478 0: OS << " elidable";
479 2: }
480 :
481 0: void StmtDumper::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
482 0: DumpExpr(Node);
483 0: OS << " ";
484 0: DumpCXXTemporary(Node->getTemporary());
485 0: }
486 :
487 0: void StmtDumper::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *Node) {
488 0: DumpExpr(Node);
489 0: ++IndentLevel;
0: branch 1 not taken
0: branch 2 not taken
490 0: for (unsigned i = 0, e = Node->getNumTemporaries(); i != e; ++i) {
491 0: OS << "\n";
492 0: Indent();
493 0: DumpCXXTemporary(Node->getTemporary(i));
494 : }
495 0: --IndentLevel;
496 0: }
497 :
498 0: void StmtDumper::DumpCXXTemporary(CXXTemporary *Temporary) {
499 0: OS << "(CXXTemporary " << (void *)Temporary << ")";
500 0: }
501 :
502 : //===----------------------------------------------------------------------===//
503 : // Obj-C Expressions
504 : //===----------------------------------------------------------------------===//
505 :
506 2: void StmtDumper::VisitObjCMessageExpr(ObjCMessageExpr* Node) {
507 2: DumpExpr(Node);
508 2: OS << " selector=" << Node->getSelector().getAsString();
1: branch 1 taken
1: branch 2 taken
509 2: if (IdentifierInfo *clsName = Node->getClassName())
510 1: OS << " class=" << clsName->getNameStart();
511 2: }
512 :
513 0: void StmtDumper::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
514 0: DumpExpr(Node);
515 0: OS << " ";
516 0: DumpType(Node->getEncodedType());
517 0: }
518 :
519 0: void StmtDumper::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
520 0: DumpExpr(Node);
521 :
522 0: OS << " " << Node->getSelector().getAsString();
523 0: }
524 :
525 0: void StmtDumper::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
526 0: DumpExpr(Node);
527 :
528 0: OS << " " << Node->getProtocol()->getNameAsString();
529 0: }
530 :
531 1: void StmtDumper::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
532 1: DumpExpr(Node);
533 :
534 : OS << " Kind=PropertyRef Property=\""
535 1: << Node->getProperty()->getNameAsString() << "\"";
536 1: }
537 :
538 : void StmtDumper::VisitObjCImplicitSetterGetterRefExpr(
539 0: ObjCImplicitSetterGetterRefExpr *Node) {
540 0: DumpExpr(Node);
541 :
542 0: ObjCMethodDecl *Getter = Node->getGetterMethod();
543 0: ObjCMethodDecl *Setter = Node->getSetterMethod();
544 : OS << " Kind=MethodRef Getter=\""
545 : << Getter->getSelector().getAsString()
546 0: << "\" Setter=\"";
0: branch 0 not taken
0: branch 1 not taken
547 0: if (Setter)
548 0: OS << Setter->getSelector().getAsString();
549 : else
550 0: OS << "(null)";
551 0: OS << "\"";
552 0: }
553 :
554 2: void StmtDumper::VisitObjCSuperExpr(ObjCSuperExpr *Node) {
555 2: DumpExpr(Node);
556 2: OS << " super";
557 2: }
558 :
559 : //===----------------------------------------------------------------------===//
560 : // Stmt method implementations
561 : //===----------------------------------------------------------------------===//
562 :
563 : /// dump - This does a local dump of the specified AST fragment. It dumps the
564 : /// specified node and a few nodes underneath it, but not the whole subtree.
565 : /// This is useful in a debugger.
566 24: void Stmt::dump(SourceManager &SM) const {
567 24: StmtDumper P(&SM, llvm::errs(), 4);
568 24: P.DumpSubTree(const_cast<Stmt*>(this));
569 24: llvm::errs() << "\n";
570 24: }
571 :
572 : /// dump - This does a local dump of the specified AST fragment. It dumps the
573 : /// specified node and a few nodes underneath it, but not the whole subtree.
574 : /// This is useful in a debugger.
575 0: void Stmt::dump() const {
576 0: StmtDumper P(0, llvm::errs(), 4);
577 0: P.DumpSubTree(const_cast<Stmt*>(this));
578 0: llvm::errs() << "\n";
579 0: }
580 :
581 : /// dumpAll - This does a dump of the specified AST fragment and all subtrees.
582 0: void Stmt::dumpAll(SourceManager &SM) const {
583 0: StmtDumper P(&SM, llvm::errs(), ~0U);
584 0: P.DumpSubTree(const_cast<Stmt*>(this));
585 0: llvm::errs() << "\n";
586 0: }
587 :
588 : /// dumpAll - This does a dump of the specified AST fragment and all subtrees.
589 0: void Stmt::dumpAll() const {
590 0: StmtDumper P(0, llvm::errs(), ~0U);
591 0: P.DumpSubTree(const_cast<Stmt*>(this));
592 0: llvm::errs() << "\n";
593 0: }
Generated: 2010-02-10 01:31 by zcov