blob: cd0e8822a8ab00bdeb1bf89e41d987e2c439e2d9 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- StmtPrinter.cpp - Printing implementation for Stmt ASTs ----------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
Chris Lattner6000dac2007-08-08 22:51:59 +000010// This file implements the Stmt::dumpPretty/Stmt::printPretty methods, which
11// pretty print the AST back out to C code.
Reid Spencer5f016e22007-07-11 17:01:13 +000012//
13//===----------------------------------------------------------------------===//
14
15#include "clang/AST/StmtVisitor.h"
Douglas Gregor1a49af92009-01-06 05:10:23 +000016#include "clang/AST/DeclCXX.h"
Ted Kremenek91d1d7a2007-10-17 18:36:42 +000017#include "clang/AST/DeclObjC.h"
Ted Kremenek42a509f2007-08-31 21:30:12 +000018#include "clang/AST/PrettyPrinter.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000019#include "llvm/Support/Compiler.h"
Ted Kremenek51221ec2007-11-26 22:50:46 +000020#include "llvm/Support/Streams.h"
Ted Kremeneka95d3752008-09-13 05:16:45 +000021#include "llvm/Support/Format.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000022using namespace clang;
23
24//===----------------------------------------------------------------------===//
25// StmtPrinter Visitor
26//===----------------------------------------------------------------------===//
27
28namespace {
Chris Lattnerc5598cb2007-08-21 04:04:25 +000029 class VISIBILITY_HIDDEN StmtPrinter : public StmtVisitor<StmtPrinter> {
Ted Kremeneka95d3752008-09-13 05:16:45 +000030 llvm::raw_ostream &OS;
Reid Spencer5f016e22007-07-11 17:01:13 +000031 unsigned IndentLevel;
Mike Stump071e4da2009-02-10 20:16:46 +000032 bool NoIndent;
Ted Kremenek42a509f2007-08-31 21:30:12 +000033 clang::PrinterHelper* Helper;
Reid Spencer5f016e22007-07-11 17:01:13 +000034 public:
Mike Stump071e4da2009-02-10 20:16:46 +000035 StmtPrinter(llvm::raw_ostream &os, PrinterHelper* helper, unsigned I=0,
36 bool noIndent=false) :
37 OS(os), IndentLevel(I), NoIndent(noIndent), Helper(helper) {}
Reid Spencer5f016e22007-07-11 17:01:13 +000038
39 void PrintStmt(Stmt *S, int SubIndent = 1) {
40 IndentLevel += SubIndent;
41 if (S && isa<Expr>(S)) {
42 // If this is an expr used in a stmt context, indent and newline it.
43 Indent();
Chris Lattnerc5598cb2007-08-21 04:04:25 +000044 Visit(S);
Reid Spencer5f016e22007-07-11 17:01:13 +000045 OS << ";\n";
46 } else if (S) {
Chris Lattnerc5598cb2007-08-21 04:04:25 +000047 Visit(S);
Reid Spencer5f016e22007-07-11 17:01:13 +000048 } else {
49 Indent() << "<<<NULL STATEMENT>>>\n";
50 }
51 IndentLevel -= SubIndent;
52 }
53
54 void PrintRawCompoundStmt(CompoundStmt *S);
55 void PrintRawDecl(Decl *D);
Ted Kremenekecd64c52008-10-06 18:39:36 +000056 void PrintRawDeclStmt(DeclStmt *S);
Mike Stump071e4da2009-02-10 20:16:46 +000057 void PrintFieldDecl(FieldDecl *FD);
Reid Spencer5f016e22007-07-11 17:01:13 +000058 void PrintRawIfStmt(IfStmt *If);
Sebastian Redl8351da02008-12-22 21:35:02 +000059 void PrintRawCXXCatchStmt(CXXCatchStmt *Catch);
Reid Spencer5f016e22007-07-11 17:01:13 +000060
61 void PrintExpr(Expr *E) {
62 if (E)
Chris Lattnerc5598cb2007-08-21 04:04:25 +000063 Visit(E);
Reid Spencer5f016e22007-07-11 17:01:13 +000064 else
65 OS << "<null expr>";
66 }
67
Mike Stump071e4da2009-02-10 20:16:46 +000068 llvm::raw_ostream &Indent(int Delta = 0) {
69 if (!NoIndent) {
70 for (int i = 0, e = IndentLevel+Delta; i < e; ++i)
71 OS << " ";
72 } else NoIndent = false;
Reid Spencer5f016e22007-07-11 17:01:13 +000073 return OS;
74 }
75
Chris Lattner704fe352007-08-30 17:59:59 +000076 bool PrintOffsetOfDesignator(Expr *E);
77 void VisitUnaryOffsetOf(UnaryOperator *Node);
78
Ted Kremenek42a509f2007-08-31 21:30:12 +000079 void Visit(Stmt* S) {
80 if (Helper && Helper->handledStmt(S,OS))
81 return;
82 else StmtVisitor<StmtPrinter>::Visit(S);
83 }
84
Chris Lattnerc5598cb2007-08-21 04:04:25 +000085 void VisitStmt(Stmt *Node);
Douglas Gregorf2cad862008-11-14 12:46:07 +000086#define STMT(CLASS, PARENT) \
Chris Lattnerc5598cb2007-08-21 04:04:25 +000087 void Visit##CLASS(CLASS *Node);
Reid Spencer5f016e22007-07-11 17:01:13 +000088#include "clang/AST/StmtNodes.def"
89 };
90}
91
92//===----------------------------------------------------------------------===//
93// Stmt printing methods.
94//===----------------------------------------------------------------------===//
95
96void StmtPrinter::VisitStmt(Stmt *Node) {
97 Indent() << "<<unknown stmt type>>\n";
98}
99
100/// PrintRawCompoundStmt - Print a compound stmt without indenting the {, and
101/// with no newline after the }.
102void StmtPrinter::PrintRawCompoundStmt(CompoundStmt *Node) {
103 OS << "{\n";
104 for (CompoundStmt::body_iterator I = Node->body_begin(), E = Node->body_end();
105 I != E; ++I)
106 PrintStmt(*I);
107
108 Indent() << "}";
109}
110
111void StmtPrinter::PrintRawDecl(Decl *D) {
112 // FIXME: Need to complete/beautify this... this code simply shows the
113 // nodes are where they need to be.
114 if (TypedefDecl *localType = dyn_cast<TypedefDecl>(D)) {
115 OS << "typedef " << localType->getUnderlyingType().getAsString();
Chris Lattner39f34e92008-11-24 04:00:27 +0000116 OS << " " << localType->getNameAsString();
Reid Spencer5f016e22007-07-11 17:01:13 +0000117 } else if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
118 // Emit storage class for vardecls.
119 if (VarDecl *V = dyn_cast<VarDecl>(VD)) {
120 switch (V->getStorageClass()) {
121 default: assert(0 && "Unknown storage class!");
Mike Stumpc5840c02009-02-10 23:49:50 +0000122 case VarDecl::None: break;
123 case VarDecl::Extern: OS << "extern "; break;
124 case VarDecl::Static: OS << "static "; break;
125 case VarDecl::Auto: OS << "auto "; break;
126 case VarDecl::Register: OS << "register "; break;
127 case VarDecl::PrivateExtern: OS << "__private_extern "; break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000128 }
129 }
130
Chris Lattner39f34e92008-11-24 04:00:27 +0000131 std::string Name = VD->getNameAsString();
Reid Spencer5f016e22007-07-11 17:01:13 +0000132 VD->getType().getAsStringInternal(Name);
133 OS << Name;
134
Chris Lattner24c39902007-07-12 00:36:32 +0000135 // If this is a vardecl with an initializer, emit it.
136 if (VarDecl *V = dyn_cast<VarDecl>(VD)) {
137 if (V->getInit()) {
138 OS << " = ";
139 PrintExpr(V->getInit());
140 }
141 }
Steve Naroff91578f32007-11-17 21:21:01 +0000142 } else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
143 // print a free standing tag decl (e.g. "struct x;").
144 OS << TD->getKindName();
145 OS << " ";
146 if (const IdentifierInfo *II = TD->getIdentifier())
147 OS << II->getName();
Mike Stump071e4da2009-02-10 20:16:46 +0000148 if (RecordDecl *RD = dyn_cast<RecordDecl>(TD)) {
149 OS << "{\n";
150 IndentLevel += 1;
151 for (RecordDecl::field_iterator i = RD->field_begin(); i != RD->field_end(); ++i) {
152 PrintFieldDecl(*i);
153 IndentLevel -= 1;
154 }
155 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000156 } else {
Reid Spencer5f016e22007-07-11 17:01:13 +0000157 assert(0 && "Unexpected decl");
158 }
159}
160
Mike Stump071e4da2009-02-10 20:16:46 +0000161void StmtPrinter::PrintFieldDecl(FieldDecl *FD) {
162 Indent() << FD->getNameAsString() << "\n";
163}
164
Ted Kremenekecd64c52008-10-06 18:39:36 +0000165void StmtPrinter::PrintRawDeclStmt(DeclStmt *S) {
Mike Stump071e4da2009-02-10 20:16:46 +0000166 bool isFirst = true;
Ted Kremenekecd64c52008-10-06 18:39:36 +0000167
168 for (DeclStmt::decl_iterator I = S->decl_begin(), E = S->decl_end();
169 I != E; ++I) {
170
171 if (!isFirst) OS << ", ";
172 else isFirst = false;
173
174 PrintRawDecl(*I);
175 }
176}
Reid Spencer5f016e22007-07-11 17:01:13 +0000177
178void StmtPrinter::VisitNullStmt(NullStmt *Node) {
179 Indent() << ";\n";
180}
181
182void StmtPrinter::VisitDeclStmt(DeclStmt *Node) {
Ted Kremenekecd64c52008-10-06 18:39:36 +0000183 for (DeclStmt::decl_iterator I = Node->decl_begin(), E = Node->decl_end();
184 I!=E; ++I) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000185 Indent();
Ted Kremenekecd64c52008-10-06 18:39:36 +0000186 PrintRawDecl(*I);
Reid Spencer5f016e22007-07-11 17:01:13 +0000187 OS << ";\n";
188 }
189}
190
191void StmtPrinter::VisitCompoundStmt(CompoundStmt *Node) {
192 Indent();
193 PrintRawCompoundStmt(Node);
194 OS << "\n";
195}
196
197void StmtPrinter::VisitCaseStmt(CaseStmt *Node) {
198 Indent(-1) << "case ";
199 PrintExpr(Node->getLHS());
200 if (Node->getRHS()) {
201 OS << " ... ";
202 PrintExpr(Node->getRHS());
203 }
204 OS << ":\n";
205
206 PrintStmt(Node->getSubStmt(), 0);
207}
208
209void StmtPrinter::VisitDefaultStmt(DefaultStmt *Node) {
210 Indent(-1) << "default:\n";
211 PrintStmt(Node->getSubStmt(), 0);
212}
213
214void StmtPrinter::VisitLabelStmt(LabelStmt *Node) {
215 Indent(-1) << Node->getName() << ":\n";
216 PrintStmt(Node->getSubStmt(), 0);
217}
218
219void StmtPrinter::PrintRawIfStmt(IfStmt *If) {
Sebastian Redlbfee9b22009-02-07 20:05:48 +0000220 OS << "if (";
Reid Spencer5f016e22007-07-11 17:01:13 +0000221 PrintExpr(If->getCond());
Sebastian Redlbfee9b22009-02-07 20:05:48 +0000222 OS << ')';
Reid Spencer5f016e22007-07-11 17:01:13 +0000223
224 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(If->getThen())) {
225 OS << ' ';
226 PrintRawCompoundStmt(CS);
227 OS << (If->getElse() ? ' ' : '\n');
228 } else {
229 OS << '\n';
230 PrintStmt(If->getThen());
231 if (If->getElse()) Indent();
232 }
233
234 if (Stmt *Else = If->getElse()) {
235 OS << "else";
236
237 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Else)) {
238 OS << ' ';
239 PrintRawCompoundStmt(CS);
240 OS << '\n';
241 } else if (IfStmt *ElseIf = dyn_cast<IfStmt>(Else)) {
242 OS << ' ';
243 PrintRawIfStmt(ElseIf);
244 } else {
245 OS << '\n';
246 PrintStmt(If->getElse());
247 }
248 }
249}
250
251void StmtPrinter::VisitIfStmt(IfStmt *If) {
252 Indent();
253 PrintRawIfStmt(If);
254}
255
256void StmtPrinter::VisitSwitchStmt(SwitchStmt *Node) {
257 Indent() << "switch (";
258 PrintExpr(Node->getCond());
259 OS << ")";
260
261 // Pretty print compoundstmt bodies (very common).
262 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
263 OS << " ";
264 PrintRawCompoundStmt(CS);
265 OS << "\n";
266 } else {
267 OS << "\n";
268 PrintStmt(Node->getBody());
269 }
270}
271
Anders Carlssonc1fcb772007-07-22 07:07:56 +0000272void StmtPrinter::VisitSwitchCase(SwitchCase*) {
273 assert(0 && "SwitchCase is an abstract class");
274}
275
Reid Spencer5f016e22007-07-11 17:01:13 +0000276void StmtPrinter::VisitWhileStmt(WhileStmt *Node) {
277 Indent() << "while (";
278 PrintExpr(Node->getCond());
279 OS << ")\n";
280 PrintStmt(Node->getBody());
281}
282
283void StmtPrinter::VisitDoStmt(DoStmt *Node) {
Chris Lattner8bdcc472007-09-15 21:49:37 +0000284 Indent() << "do ";
285 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
286 PrintRawCompoundStmt(CS);
287 OS << " ";
288 } else {
289 OS << "\n";
290 PrintStmt(Node->getBody());
291 Indent();
292 }
293
294 OS << "while ";
Reid Spencer5f016e22007-07-11 17:01:13 +0000295 PrintExpr(Node->getCond());
296 OS << ";\n";
297}
298
299void StmtPrinter::VisitForStmt(ForStmt *Node) {
300 Indent() << "for (";
301 if (Node->getInit()) {
302 if (DeclStmt *DS = dyn_cast<DeclStmt>(Node->getInit()))
Ted Kremenekecd64c52008-10-06 18:39:36 +0000303 PrintRawDeclStmt(DS);
Reid Spencer5f016e22007-07-11 17:01:13 +0000304 else
305 PrintExpr(cast<Expr>(Node->getInit()));
306 }
Chris Lattner8bdcc472007-09-15 21:49:37 +0000307 OS << ";";
308 if (Node->getCond()) {
309 OS << " ";
Reid Spencer5f016e22007-07-11 17:01:13 +0000310 PrintExpr(Node->getCond());
Chris Lattner8bdcc472007-09-15 21:49:37 +0000311 }
312 OS << ";";
313 if (Node->getInc()) {
314 OS << " ";
Reid Spencer5f016e22007-07-11 17:01:13 +0000315 PrintExpr(Node->getInc());
Chris Lattner8bdcc472007-09-15 21:49:37 +0000316 }
317 OS << ") ";
318
319 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
320 PrintRawCompoundStmt(CS);
321 OS << "\n";
322 } else {
323 OS << "\n";
324 PrintStmt(Node->getBody());
325 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000326}
327
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000328void StmtPrinter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *Node) {
Fariborz Jahanian0196cab2008-01-02 22:54:34 +0000329 Indent() << "for (";
330 if (DeclStmt *DS = dyn_cast<DeclStmt>(Node->getElement()))
Ted Kremenekecd64c52008-10-06 18:39:36 +0000331 PrintRawDeclStmt(DS);
Fariborz Jahanian0196cab2008-01-02 22:54:34 +0000332 else
333 PrintExpr(cast<Expr>(Node->getElement()));
334 OS << " in ";
335 PrintExpr(Node->getCollection());
336 OS << ") ";
337
338 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
339 PrintRawCompoundStmt(CS);
340 OS << "\n";
341 } else {
342 OS << "\n";
343 PrintStmt(Node->getBody());
344 }
345}
346
Reid Spencer5f016e22007-07-11 17:01:13 +0000347void StmtPrinter::VisitGotoStmt(GotoStmt *Node) {
348 Indent() << "goto " << Node->getLabel()->getName() << ";\n";
349}
350
351void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) {
352 Indent() << "goto *";
353 PrintExpr(Node->getTarget());
354 OS << ";\n";
355}
356
357void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) {
358 Indent() << "continue;\n";
359}
360
361void StmtPrinter::VisitBreakStmt(BreakStmt *Node) {
362 Indent() << "break;\n";
363}
364
365
366void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) {
367 Indent() << "return";
368 if (Node->getRetValue()) {
369 OS << " ";
370 PrintExpr(Node->getRetValue());
371 }
372 OS << ";\n";
373}
374
Chris Lattnerfe795952007-10-29 04:04:16 +0000375
376void StmtPrinter::VisitAsmStmt(AsmStmt *Node) {
Anders Carlsson39c47b52007-11-23 23:12:25 +0000377 Indent() << "asm ";
378
379 if (Node->isVolatile())
380 OS << "volatile ";
381
382 OS << "(";
Anders Carlsson6a0ef4b2007-11-20 19:21:03 +0000383 VisitStringLiteral(Node->getAsmString());
Anders Carlssonb235fc22007-11-22 01:36:19 +0000384
385 // Outputs
386 if (Node->getNumOutputs() != 0 || Node->getNumInputs() != 0 ||
387 Node->getNumClobbers() != 0)
388 OS << " : ";
389
390 for (unsigned i = 0, e = Node->getNumOutputs(); i != e; ++i) {
391 if (i != 0)
392 OS << ", ";
393
394 if (!Node->getOutputName(i).empty()) {
395 OS << '[';
396 OS << Node->getOutputName(i);
397 OS << "] ";
398 }
399
Chris Lattnerb3277932009-03-10 04:59:06 +0000400 VisitStringLiteral(Node->getOutputConstraintLiteral(i));
Anders Carlssonb235fc22007-11-22 01:36:19 +0000401 OS << " ";
402 Visit(Node->getOutputExpr(i));
403 }
404
405 // Inputs
406 if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0)
407 OS << " : ";
408
409 for (unsigned i = 0, e = Node->getNumInputs(); i != e; ++i) {
410 if (i != 0)
411 OS << ", ";
412
413 if (!Node->getInputName(i).empty()) {
414 OS << '[';
415 OS << Node->getInputName(i);
416 OS << "] ";
417 }
418
Chris Lattnerb3277932009-03-10 04:59:06 +0000419 VisitStringLiteral(Node->getInputConstraintLiteral(i));
Anders Carlssonb235fc22007-11-22 01:36:19 +0000420 OS << " ";
421 Visit(Node->getInputExpr(i));
422 }
423
424 // Clobbers
425 if (Node->getNumClobbers() != 0)
426 OS << " : ";
427
428 for (unsigned i = 0, e = Node->getNumClobbers(); i != e; ++i) {
429 if (i != 0)
430 OS << ", ";
431
432 VisitStringLiteral(Node->getClobber(i));
433 }
434
Anders Carlsson6a0ef4b2007-11-20 19:21:03 +0000435 OS << ");\n";
Chris Lattnerfe795952007-10-29 04:04:16 +0000436}
437
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000438void StmtPrinter::VisitObjCAtTryStmt(ObjCAtTryStmt *Node) {
Fariborz Jahanian7794cb82007-11-02 18:16:07 +0000439 Indent() << "@try";
440 if (CompoundStmt *TS = dyn_cast<CompoundStmt>(Node->getTryBody())) {
441 PrintRawCompoundStmt(TS);
442 OS << "\n";
443 }
444
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000445 for (ObjCAtCatchStmt *catchStmt =
446 static_cast<ObjCAtCatchStmt *>(Node->getCatchStmts());
Fariborz Jahanian7794cb82007-11-02 18:16:07 +0000447 catchStmt;
448 catchStmt =
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000449 static_cast<ObjCAtCatchStmt *>(catchStmt->getNextCatchStmt())) {
Fariborz Jahanian7794cb82007-11-02 18:16:07 +0000450 Indent() << "@catch(";
Steve Naroff7ba138a2009-03-03 19:52:17 +0000451 if (catchStmt->getCatchParamDecl()) {
452 if (Decl *DS = catchStmt->getCatchParamDecl())
453 PrintRawDecl(DS);
Fariborz Jahanian7794cb82007-11-02 18:16:07 +0000454 }
455 OS << ")";
456 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(catchStmt->getCatchBody()))
457 {
458 PrintRawCompoundStmt(CS);
459 OS << "\n";
460 }
461 }
462
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000463 if (ObjCAtFinallyStmt *FS =static_cast<ObjCAtFinallyStmt *>(
Fariborz Jahanian1e7eab42007-11-07 00:46:42 +0000464 Node->getFinallyStmt())) {
465 Indent() << "@finally";
466 PrintRawCompoundStmt(dyn_cast<CompoundStmt>(FS->getFinallyBody()));
Fariborz Jahanian7794cb82007-11-02 18:16:07 +0000467 OS << "\n";
468 }
Fariborz Jahanianb210bd02007-11-01 21:12:44 +0000469}
470
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000471void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) {
Fariborz Jahanianb210bd02007-11-01 21:12:44 +0000472}
473
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000474void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) {
Fariborz Jahanianb210bd02007-11-01 21:12:44 +0000475 Indent() << "@catch (...) { /* todo */ } \n";
476}
477
Fariborz Jahanian78a677b2008-01-30 17:38:29 +0000478void StmtPrinter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *Node) {
Fariborz Jahanian39f8f152007-11-07 02:00:49 +0000479 Indent() << "@throw";
480 if (Node->getThrowExpr()) {
481 OS << " ";
482 PrintExpr(Node->getThrowExpr());
483 }
484 OS << ";\n";
485}
486
Fariborz Jahanian78a677b2008-01-30 17:38:29 +0000487void StmtPrinter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *Node) {
Fariborz Jahanianc385c902008-01-29 18:21:32 +0000488 Indent() << "@synchronized (";
489 PrintExpr(Node->getSynchExpr());
490 OS << ")";
Fariborz Jahanian78a677b2008-01-30 17:38:29 +0000491 PrintRawCompoundStmt(Node->getSynchBody());
492 OS << "\n";
Fariborz Jahanianc385c902008-01-29 18:21:32 +0000493}
494
Sebastian Redl8351da02008-12-22 21:35:02 +0000495void StmtPrinter::PrintRawCXXCatchStmt(CXXCatchStmt *Node) {
496 OS << "catch (";
Sebastian Redl4b07b292008-12-22 19:15:10 +0000497 if (Decl *ExDecl = Node->getExceptionDecl())
498 PrintRawDecl(ExDecl);
499 else
500 OS << "...";
501 OS << ") ";
502 PrintRawCompoundStmt(cast<CompoundStmt>(Node->getHandlerBlock()));
Sebastian Redl8351da02008-12-22 21:35:02 +0000503}
504
505void StmtPrinter::VisitCXXCatchStmt(CXXCatchStmt *Node) {
506 Indent();
507 PrintRawCXXCatchStmt(Node);
508 OS << "\n";
509}
510
511void StmtPrinter::VisitCXXTryStmt(CXXTryStmt *Node) {
512 Indent() << "try ";
513 PrintRawCompoundStmt(Node->getTryBlock());
514 for(unsigned i = 0, e = Node->getNumHandlers(); i < e; ++i) {
515 OS << " ";
516 PrintRawCXXCatchStmt(Node->getHandler(i));
517 }
Sebastian Redl4b07b292008-12-22 19:15:10 +0000518 OS << "\n";
519}
520
Reid Spencer5f016e22007-07-11 17:01:13 +0000521//===----------------------------------------------------------------------===//
522// Expr printing methods.
523//===----------------------------------------------------------------------===//
524
525void StmtPrinter::VisitExpr(Expr *Node) {
526 OS << "<<unknown expr type>>";
527}
528
529void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
Chris Lattner39f34e92008-11-24 04:00:27 +0000530 OS << Node->getDecl()->getNameAsString();
Reid Spencer5f016e22007-07-11 17:01:13 +0000531}
532
Douglas Gregorbad35182009-03-19 03:51:16 +0000533void StmtPrinter::VisitQualifiedDeclRefExpr(QualifiedDeclRefExpr *Node) {
Douglas Gregor1a49af92009-01-06 05:10:23 +0000534 NamedDecl *D = Node->getDecl();
535
Douglas Gregor9bde7732009-03-31 20:22:05 +0000536 Node->getQualifier()->print(OS);
Douglas Gregor1a49af92009-01-06 05:10:23 +0000537 OS << D->getNameAsString();
538}
539
Douglas Gregor5953d8b2009-03-19 17:26:29 +0000540void StmtPrinter::VisitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *Node) {
Douglas Gregor9bde7732009-03-31 20:22:05 +0000541 Node->getQualifier()->print(OS);
Douglas Gregor5953d8b2009-03-19 17:26:29 +0000542 OS << Node->getDeclName().getAsString();
543}
544
Steve Naroff7779db42007-11-12 14:29:37 +0000545void StmtPrinter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
Fariborz Jahanian232220c2007-11-12 22:29:28 +0000546 if (Node->getBase()) {
547 PrintExpr(Node->getBase());
548 OS << (Node->isArrow() ? "->" : ".");
549 }
Chris Lattner39f34e92008-11-24 04:00:27 +0000550 OS << Node->getDecl()->getNameAsString();
Steve Naroff7779db42007-11-12 14:29:37 +0000551}
552
Steve Naroffae784072008-05-30 00:40:33 +0000553void StmtPrinter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
554 if (Node->getBase()) {
555 PrintExpr(Node->getBase());
556 OS << ".";
557 }
Steve Naroffc77a6362008-12-04 16:24:46 +0000558 OS << Node->getProperty()->getNameAsCString();
Steve Naroffae784072008-05-30 00:40:33 +0000559}
560
Fariborz Jahanian5daf5702008-11-22 18:39:36 +0000561void StmtPrinter::VisitObjCKVCRefExpr(ObjCKVCRefExpr *Node) {
562 if (Node->getBase()) {
563 PrintExpr(Node->getBase());
564 OS << ".";
565 }
566 // FIXME: Setter/Getter names
567}
568
Chris Lattnerd9f69102008-08-10 01:53:14 +0000569void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) {
Anders Carlsson22742662007-07-21 05:21:51 +0000570 switch (Node->getIdentType()) {
571 default:
572 assert(0 && "unknown case");
Chris Lattnerd9f69102008-08-10 01:53:14 +0000573 case PredefinedExpr::Func:
Anders Carlsson22742662007-07-21 05:21:51 +0000574 OS << "__func__";
575 break;
Chris Lattnerd9f69102008-08-10 01:53:14 +0000576 case PredefinedExpr::Function:
Anders Carlsson22742662007-07-21 05:21:51 +0000577 OS << "__FUNCTION__";
578 break;
Chris Lattnerd9f69102008-08-10 01:53:14 +0000579 case PredefinedExpr::PrettyFunction:
Anders Carlsson22742662007-07-21 05:21:51 +0000580 OS << "__PRETTY_FUNCTION__";
581 break;
582 }
583}
584
Reid Spencer5f016e22007-07-11 17:01:13 +0000585void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) {
Chris Lattnerb0a721a2007-07-13 05:18:11 +0000586 unsigned value = Node->getValue();
Chris Lattnerc250aae2008-06-07 22:35:38 +0000587 if (Node->isWide())
588 OS << "L";
Chris Lattner8bf9f072007-07-13 23:58:20 +0000589 switch (value) {
590 case '\\':
591 OS << "'\\\\'";
592 break;
593 case '\'':
594 OS << "'\\''";
595 break;
596 case '\a':
597 // TODO: K&R: the meaning of '\\a' is different in traditional C
598 OS << "'\\a'";
599 break;
600 case '\b':
601 OS << "'\\b'";
602 break;
603 // Nonstandard escape sequence.
604 /*case '\e':
605 OS << "'\\e'";
606 break;*/
607 case '\f':
608 OS << "'\\f'";
609 break;
610 case '\n':
611 OS << "'\\n'";
612 break;
613 case '\r':
614 OS << "'\\r'";
615 break;
616 case '\t':
617 OS << "'\\t'";
618 break;
619 case '\v':
620 OS << "'\\v'";
621 break;
622 default:
Ted Kremenek471733d2008-02-23 00:52:04 +0000623 if (value < 256 && isprint(value)) {
Chris Lattner8bf9f072007-07-13 23:58:20 +0000624 OS << "'" << (char)value << "'";
625 } else if (value < 256) {
Ted Kremeneka95d3752008-09-13 05:16:45 +0000626 OS << "'\\x" << llvm::format("%x", value) << "'";
Chris Lattner8bf9f072007-07-13 23:58:20 +0000627 } else {
628 // FIXME what to really do here?
629 OS << value;
630 }
Chris Lattnerb0a721a2007-07-13 05:18:11 +0000631 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000632}
633
634void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) {
635 bool isSigned = Node->getType()->isSignedIntegerType();
636 OS << Node->getValue().toString(10, isSigned);
637
638 // Emit suffixes. Integer literals are always a builtin integer type.
Chris Lattnerb77792e2008-07-26 22:17:49 +0000639 switch (Node->getType()->getAsBuiltinType()->getKind()) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000640 default: assert(0 && "Unexpected type for integer literal!");
641 case BuiltinType::Int: break; // no suffix.
642 case BuiltinType::UInt: OS << 'U'; break;
643 case BuiltinType::Long: OS << 'L'; break;
644 case BuiltinType::ULong: OS << "UL"; break;
645 case BuiltinType::LongLong: OS << "LL"; break;
646 case BuiltinType::ULongLong: OS << "ULL"; break;
647 }
648}
649void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) {
Chris Lattner86e499d2007-08-01 00:23:58 +0000650 // FIXME: print value more precisely.
Chris Lattnerda8249e2008-06-07 22:13:43 +0000651 OS << Node->getValueAsApproximateDouble();
Reid Spencer5f016e22007-07-11 17:01:13 +0000652}
Chris Lattner5d661452007-08-26 03:42:43 +0000653
654void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) {
655 PrintExpr(Node->getSubExpr());
656 OS << "i";
657}
658
Reid Spencer5f016e22007-07-11 17:01:13 +0000659void StmtPrinter::VisitStringLiteral(StringLiteral *Str) {
660 if (Str->isWide()) OS << 'L';
661 OS << '"';
Anders Carlssonee98ac52007-10-15 02:50:23 +0000662
Reid Spencer5f016e22007-07-11 17:01:13 +0000663 // FIXME: this doesn't print wstrings right.
664 for (unsigned i = 0, e = Str->getByteLength(); i != e; ++i) {
Chris Lattner9a81c872009-01-16 19:25:18 +0000665 unsigned char Char = Str->getStrData()[i];
666
667 switch (Char) {
668 default:
669 if (isprint(Char))
670 OS << (char)Char;
671 else // Output anything hard as an octal escape.
672 OS << '\\'
673 << (char)('0'+ ((Char >> 6) & 7))
674 << (char)('0'+ ((Char >> 3) & 7))
675 << (char)('0'+ ((Char >> 0) & 7));
676 break;
677 // Handle some common non-printable cases to make dumps prettier.
Reid Spencer5f016e22007-07-11 17:01:13 +0000678 case '\\': OS << "\\\\"; break;
679 case '"': OS << "\\\""; break;
680 case '\n': OS << "\\n"; break;
681 case '\t': OS << "\\t"; break;
682 case '\a': OS << "\\a"; break;
683 case '\b': OS << "\\b"; break;
684 }
685 }
686 OS << '"';
687}
688void StmtPrinter::VisitParenExpr(ParenExpr *Node) {
689 OS << "(";
690 PrintExpr(Node->getSubExpr());
691 OS << ")";
692}
693void StmtPrinter::VisitUnaryOperator(UnaryOperator *Node) {
Chris Lattner296bf192007-08-23 21:46:40 +0000694 if (!Node->isPostfix()) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000695 OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
Chris Lattner296bf192007-08-23 21:46:40 +0000696
Sebastian Redl05189992008-11-11 17:56:53 +0000697 // Print a space if this is an "identifier operator" like __real.
Chris Lattner296bf192007-08-23 21:46:40 +0000698 switch (Node->getOpcode()) {
699 default: break;
Chris Lattner296bf192007-08-23 21:46:40 +0000700 case UnaryOperator::Real:
701 case UnaryOperator::Imag:
702 case UnaryOperator::Extension:
703 OS << ' ';
704 break;
705 }
706 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000707 PrintExpr(Node->getSubExpr());
708
709 if (Node->isPostfix())
710 OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
Reid Spencer5f016e22007-07-11 17:01:13 +0000711}
Chris Lattner704fe352007-08-30 17:59:59 +0000712
713bool StmtPrinter::PrintOffsetOfDesignator(Expr *E) {
Eli Friedman35183ac2009-02-27 06:44:11 +0000714 if (isa<UnaryOperator>(E)) {
Chris Lattner704fe352007-08-30 17:59:59 +0000715 // Base case, print the type and comma.
716 OS << E->getType().getAsString() << ", ";
717 return true;
718 } else if (ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) {
719 PrintOffsetOfDesignator(ASE->getLHS());
720 OS << "[";
721 PrintExpr(ASE->getRHS());
722 OS << "]";
723 return false;
724 } else {
725 MemberExpr *ME = cast<MemberExpr>(E);
726 bool IsFirst = PrintOffsetOfDesignator(ME->getBase());
Chris Lattner39f34e92008-11-24 04:00:27 +0000727 OS << (IsFirst ? "" : ".") << ME->getMemberDecl()->getNameAsString();
Chris Lattner704fe352007-08-30 17:59:59 +0000728 return false;
729 }
730}
731
732void StmtPrinter::VisitUnaryOffsetOf(UnaryOperator *Node) {
733 OS << "__builtin_offsetof(";
734 PrintOffsetOfDesignator(Node->getSubExpr());
735 OS << ")";
736}
737
Sebastian Redl05189992008-11-11 17:56:53 +0000738void StmtPrinter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *Node) {
739 OS << (Node->isSizeOf() ? "sizeof" : "__alignof");
740 if (Node->isArgumentType())
741 OS << "(" << Node->getArgumentType().getAsString() << ")";
742 else {
743 OS << " ";
744 PrintExpr(Node->getArgumentExpr());
745 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000746}
747void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) {
Ted Kremenek23245122007-08-20 16:18:38 +0000748 PrintExpr(Node->getLHS());
Reid Spencer5f016e22007-07-11 17:01:13 +0000749 OS << "[";
Ted Kremenek23245122007-08-20 16:18:38 +0000750 PrintExpr(Node->getRHS());
Reid Spencer5f016e22007-07-11 17:01:13 +0000751 OS << "]";
752}
753
754void StmtPrinter::VisitCallExpr(CallExpr *Call) {
755 PrintExpr(Call->getCallee());
756 OS << "(";
757 for (unsigned i = 0, e = Call->getNumArgs(); i != e; ++i) {
Chris Lattner04421082008-04-08 04:40:51 +0000758 if (isa<CXXDefaultArgExpr>(Call->getArg(i))) {
759 // Don't print any defaulted arguments
760 break;
761 }
762
Reid Spencer5f016e22007-07-11 17:01:13 +0000763 if (i) OS << ", ";
764 PrintExpr(Call->getArg(i));
765 }
766 OS << ")";
767}
768void StmtPrinter::VisitMemberExpr(MemberExpr *Node) {
Douglas Gregorb3eef682009-01-08 22:45:41 +0000769 // FIXME: Suppress printing implicit bases (like "this")
770 PrintExpr(Node->getBase());
771 OS << (Node->isArrow() ? "->" : ".");
772 // FIXME: Suppress printing references to unnamed objects
773 // representing anonymous unions/structs
Douglas Gregor86f19402008-12-20 23:49:58 +0000774 OS << Node->getMemberDecl()->getNameAsString();
Reid Spencer5f016e22007-07-11 17:01:13 +0000775}
Nate Begeman213541a2008-04-18 23:10:10 +0000776void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
Steve Naroff31a45842007-07-28 23:10:27 +0000777 PrintExpr(Node->getBase());
778 OS << ".";
779 OS << Node->getAccessor().getName();
780}
Argyrios Kyrtzidis0835a3c2008-08-18 23:01:59 +0000781void StmtPrinter::VisitCastExpr(CastExpr *) {
782 assert(0 && "CastExpr is an abstract class");
783}
Douglas Gregor49badde2008-10-27 19:41:14 +0000784void StmtPrinter::VisitExplicitCastExpr(ExplicitCastExpr *) {
785 assert(0 && "ExplicitCastExpr is an abstract class");
786}
Douglas Gregor6eec8e82008-10-28 15:36:24 +0000787void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) {
Chris Lattner26dc7b32007-07-15 23:54:50 +0000788 OS << "(" << Node->getType().getAsString() << ")";
Reid Spencer5f016e22007-07-11 17:01:13 +0000789 PrintExpr(Node->getSubExpr());
790}
Steve Naroffaff1edd2007-07-19 21:32:11 +0000791void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) {
792 OS << "(" << Node->getType().getAsString() << ")";
793 PrintExpr(Node->getInitializer());
794}
Steve Naroff49b45262007-07-13 16:58:59 +0000795void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
Steve Naroff90045e82007-07-13 23:32:42 +0000796 // No need to print anything, simply forward to the sub expression.
797 PrintExpr(Node->getSubExpr());
Steve Naroff49b45262007-07-13 16:58:59 +0000798}
Reid Spencer5f016e22007-07-11 17:01:13 +0000799void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) {
800 PrintExpr(Node->getLHS());
801 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
802 PrintExpr(Node->getRHS());
803}
Chris Lattnereb14fe82007-08-25 02:00:02 +0000804void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
805 PrintExpr(Node->getLHS());
806 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
807 PrintExpr(Node->getRHS());
808}
Reid Spencer5f016e22007-07-11 17:01:13 +0000809void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) {
810 PrintExpr(Node->getCond());
Ted Kremenek8e911c42007-11-26 18:27:54 +0000811
812 if (Node->getLHS()) {
813 OS << " ? ";
814 PrintExpr(Node->getLHS());
815 OS << " : ";
816 }
817 else { // Handle GCC extention where LHS can be NULL.
818 OS << " ?: ";
819 }
820
Reid Spencer5f016e22007-07-11 17:01:13 +0000821 PrintExpr(Node->getRHS());
822}
823
824// GNU extensions.
825
Chris Lattner6481a572007-08-03 17:31:20 +0000826void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000827 OS << "&&" << Node->getLabel()->getName();
Reid Spencer5f016e22007-07-11 17:01:13 +0000828}
829
Chris Lattnerab18c4c2007-07-24 16:58:17 +0000830void StmtPrinter::VisitStmtExpr(StmtExpr *E) {
831 OS << "(";
832 PrintRawCompoundStmt(E->getSubStmt());
833 OS << ")";
834}
835
Steve Naroffd34e9152007-08-01 22:05:33 +0000836void StmtPrinter::VisitTypesCompatibleExpr(TypesCompatibleExpr *Node) {
837 OS << "__builtin_types_compatible_p(";
838 OS << Node->getArgType1().getAsString() << ",";
839 OS << Node->getArgType2().getAsString() << ")";
840}
841
Steve Naroffd04fdd52007-08-03 21:21:27 +0000842void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) {
843 OS << "__builtin_choose_expr(";
844 PrintExpr(Node->getCond());
Chris Lattner94f05e32007-08-04 00:20:15 +0000845 OS << ", ";
Steve Naroffd04fdd52007-08-03 21:21:27 +0000846 PrintExpr(Node->getLHS());
Chris Lattner94f05e32007-08-04 00:20:15 +0000847 OS << ", ";
Steve Naroffd04fdd52007-08-03 21:21:27 +0000848 PrintExpr(Node->getRHS());
849 OS << ")";
850}
Chris Lattnerab18c4c2007-07-24 16:58:17 +0000851
Douglas Gregor2d8b2732008-11-29 04:51:27 +0000852void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {
853 OS << "__null";
854}
855
Eli Friedmand38617c2008-05-14 19:38:39 +0000856void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) {
857 OS << "__builtin_shufflevector(";
858 for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) {
859 if (i) OS << ", ";
860 PrintExpr(Node->getExpr(i));
861 }
862 OS << ")";
863}
864
Anders Carlsson66b5a8a2007-08-31 04:56:16 +0000865void StmtPrinter::VisitInitListExpr(InitListExpr* Node) {
866 OS << "{ ";
867 for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) {
868 if (i) OS << ", ";
Douglas Gregor4c678342009-01-28 21:54:33 +0000869 if (Node->getInit(i))
870 PrintExpr(Node->getInit(i));
871 else
872 OS << "0";
Anders Carlsson66b5a8a2007-08-31 04:56:16 +0000873 }
874 OS << " }";
875}
876
Douglas Gregor05c13a32009-01-22 00:58:24 +0000877void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) {
Douglas Gregor4c678342009-01-28 21:54:33 +0000878 for (DesignatedInitExpr::designators_iterator D = Node->designators_begin(),
879 DEnd = Node->designators_end();
880 D != DEnd; ++D) {
881 if (D->isFieldDesignator()) {
882 if (D->getDotLoc().isInvalid())
883 OS << D->getFieldName()->getName() << ":";
884 else
885 OS << "." << D->getFieldName()->getName();
886 } else {
887 OS << "[";
888 if (D->isArrayDesignator()) {
889 PrintExpr(Node->getArrayIndex(*D));
890 } else {
891 PrintExpr(Node->getArrayRangeStart(*D));
892 OS << " ... ";
893 PrintExpr(Node->getArrayRangeEnd(*D));
894 }
895 OS << "]";
896 }
897 }
898
899 OS << " = ";
900 PrintExpr(Node->getInit());
Douglas Gregor05c13a32009-01-22 00:58:24 +0000901}
902
Douglas Gregor3498bdb2009-01-29 17:44:32 +0000903void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) {
904 OS << "/*implicit*/" << Node->getType().getAsString() << "()";
905}
906
Anders Carlsson7c50aca2007-10-15 20:28:48 +0000907void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) {
908 OS << "va_arg(";
909 PrintExpr(Node->getSubExpr());
910 OS << ", ";
911 OS << Node->getType().getAsString();
912 OS << ")";
913}
914
Reid Spencer5f016e22007-07-11 17:01:13 +0000915// C++
Douglas Gregorb4609802008-11-14 16:09:21 +0000916void StmtPrinter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *Node) {
917 const char *OpStrings[NUM_OVERLOADED_OPERATORS] = {
918 "",
919#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
920 Spelling,
921#include "clang/Basic/OperatorKinds.def"
922 };
923
924 OverloadedOperatorKind Kind = Node->getOperator();
925 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
926 if (Node->getNumArgs() == 1) {
927 OS << OpStrings[Kind] << ' ';
928 PrintExpr(Node->getArg(0));
929 } else {
930 PrintExpr(Node->getArg(0));
931 OS << ' ' << OpStrings[Kind];
932 }
933 } else if (Kind == OO_Call) {
934 PrintExpr(Node->getArg(0));
935 OS << '(';
936 for (unsigned ArgIdx = 1; ArgIdx < Node->getNumArgs(); ++ArgIdx) {
937 if (ArgIdx > 1)
938 OS << ", ";
939 if (!isa<CXXDefaultArgExpr>(Node->getArg(ArgIdx)))
940 PrintExpr(Node->getArg(ArgIdx));
941 }
942 OS << ')';
943 } else if (Kind == OO_Subscript) {
944 PrintExpr(Node->getArg(0));
945 OS << '[';
946 PrintExpr(Node->getArg(1));
947 OS << ']';
948 } else if (Node->getNumArgs() == 1) {
949 OS << OpStrings[Kind] << ' ';
950 PrintExpr(Node->getArg(0));
951 } else if (Node->getNumArgs() == 2) {
952 PrintExpr(Node->getArg(0));
953 OS << ' ' << OpStrings[Kind] << ' ';
954 PrintExpr(Node->getArg(1));
955 } else {
956 assert(false && "unknown overloaded operator");
957 }
958}
Reid Spencer5f016e22007-07-11 17:01:13 +0000959
Douglas Gregor88a35142008-12-22 05:46:06 +0000960void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) {
961 VisitCallExpr(cast<CallExpr>(Node));
962}
963
Douglas Gregor49badde2008-10-27 19:41:14 +0000964void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
965 OS << Node->getCastName() << '<';
966 OS << Node->getTypeAsWritten().getAsString() << ">(";
Reid Spencer5f016e22007-07-11 17:01:13 +0000967 PrintExpr(Node->getSubExpr());
968 OS << ")";
969}
970
Douglas Gregor49badde2008-10-27 19:41:14 +0000971void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) {
972 VisitCXXNamedCastExpr(Node);
973}
974
975void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) {
976 VisitCXXNamedCastExpr(Node);
977}
978
979void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
980 VisitCXXNamedCastExpr(Node);
981}
982
983void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
984 VisitCXXNamedCastExpr(Node);
985}
986
Sebastian Redlc42e1182008-11-11 11:37:55 +0000987void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) {
988 OS << "typeid(";
989 if (Node->isTypeOperand()) {
990 OS << Node->getTypeOperand().getAsString();
991 } else {
992 PrintExpr(Node->getExprOperand());
993 }
994 OS << ")";
995}
996
Reid Spencer5f016e22007-07-11 17:01:13 +0000997void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
998 OS << (Node->getValue() ? "true" : "false");
999}
1000
Douglas Gregor796da182008-11-04 14:32:21 +00001001void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) {
1002 OS << "this";
1003}
1004
Chris Lattner50dd2892008-02-26 00:51:44 +00001005void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) {
1006 if (Node->getSubExpr() == 0)
1007 OS << "throw";
1008 else {
1009 OS << "throw ";
1010 PrintExpr(Node->getSubExpr());
1011 }
1012}
1013
Chris Lattner04421082008-04-08 04:40:51 +00001014void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
1015 // Nothing to print: we picked up the default argument
1016}
1017
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001018void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
1019 OS << Node->getType().getAsString();
1020 OS << "(";
1021 PrintExpr(Node->getSubExpr());
1022 OS << ")";
1023}
1024
Douglas Gregor506ae412009-01-16 18:33:17 +00001025void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) {
1026 OS << Node->getType().getAsString();
1027 OS << "(";
1028 for (CXXTemporaryObjectExpr::arg_iterator Arg = Node->arg_begin(),
1029 ArgEnd = Node->arg_end();
1030 Arg != ArgEnd; ++Arg) {
1031 if (Arg != Node->arg_begin())
1032 OS << ", ";
1033 PrintExpr(*Arg);
1034 }
1035 OS << ")";
1036}
1037
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001038void StmtPrinter::VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *Node) {
1039 OS << Node->getType().getAsString() << "()";
1040}
1041
Argyrios Kyrtzidis9e922b12008-09-09 23:47:53 +00001042void
1043StmtPrinter::VisitCXXConditionDeclExpr(CXXConditionDeclExpr *E) {
1044 PrintRawDecl(E->getVarDecl());
1045}
1046
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001047void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) {
1048 if (E->isGlobalNew())
1049 OS << "::";
1050 OS << "new ";
1051 unsigned NumPlace = E->getNumPlacementArgs();
1052 if (NumPlace > 0) {
1053 OS << "(";
1054 PrintExpr(E->getPlacementArg(0));
1055 for (unsigned i = 1; i < NumPlace; ++i) {
1056 OS << ", ";
1057 PrintExpr(E->getPlacementArg(i));
1058 }
1059 OS << ") ";
1060 }
1061 if (E->isParenTypeId())
1062 OS << "(";
Sebastian Redl6fec6482008-12-02 22:08:59 +00001063 std::string TypeS;
1064 if (Expr *Size = E->getArraySize()) {
1065 llvm::raw_string_ostream s(TypeS);
1066 Size->printPretty(s);
1067 s.flush();
1068 TypeS = "[" + TypeS + "]";
1069 }
1070 E->getAllocatedType().getAsStringInternal(TypeS);
1071 OS << TypeS;
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001072 if (E->isParenTypeId())
1073 OS << ")";
1074
1075 if (E->hasInitializer()) {
1076 OS << "(";
1077 unsigned NumCons = E->getNumConstructorArgs();
1078 if (NumCons > 0) {
1079 PrintExpr(E->getConstructorArg(0));
1080 for (unsigned i = 1; i < NumCons; ++i) {
1081 OS << ", ";
1082 PrintExpr(E->getConstructorArg(i));
1083 }
1084 }
1085 OS << ")";
1086 }
1087}
1088
1089void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1090 if (E->isGlobalDelete())
1091 OS << "::";
1092 OS << "delete ";
1093 if (E->isArrayForm())
1094 OS << "[] ";
1095 PrintExpr(E->getArgument());
1096}
1097
Douglas Gregor17330012009-02-04 15:01:18 +00001098void StmtPrinter::VisitUnresolvedFunctionNameExpr(UnresolvedFunctionNameExpr *E) {
1099 OS << E->getName().getAsString();
Douglas Gregor5c37de72008-12-06 00:22:45 +00001100}
1101
Sebastian Redl64b45f72009-01-05 20:52:13 +00001102static const char *getTypeTraitName(UnaryTypeTrait UTT) {
1103 switch (UTT) {
1104 default: assert(false && "Unknown type trait");
1105 case UTT_HasNothrowAssign: return "__has_nothrow_assign";
1106 case UTT_HasNothrowCopy: return "__has_nothrow_copy";
1107 case UTT_HasNothrowConstructor: return "__has_nothrow_constructor";
1108 case UTT_HasTrivialAssign: return "__has_trivial_assign";
1109 case UTT_HasTrivialCopy: return "__has_trivial_copy";
1110 case UTT_HasTrivialConstructor: return "__has_trivial_constructor";
1111 case UTT_HasTrivialDestructor: return "__has_trivial_destructor";
1112 case UTT_HasVirtualDestructor: return "__has_virtual_destructor";
1113 case UTT_IsAbstract: return "__is_abstract";
1114 case UTT_IsClass: return "__is_class";
1115 case UTT_IsEmpty: return "__is_empty";
1116 case UTT_IsEnum: return "__is_enum";
1117 case UTT_IsPOD: return "__is_pod";
1118 case UTT_IsPolymorphic: return "__is_polymorphic";
1119 case UTT_IsUnion: return "__is_union";
1120 }
1121}
1122
1123void StmtPrinter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1124 OS << getTypeTraitName(E->getTrait()) << "("
1125 << E->getQueriedType().getAsString() << ")";
1126}
1127
Anders Carlsson55085182007-08-21 17:43:55 +00001128// Obj-C
1129
1130void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) {
1131 OS << "@";
1132 VisitStringLiteral(Node->getString());
1133}
Reid Spencer5f016e22007-07-11 17:01:13 +00001134
Anders Carlssonf9bcf012007-08-22 15:14:15 +00001135void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
Chris Lattner39f34e92008-11-24 04:00:27 +00001136 OS << "@encode(" << Node->getEncodedType().getAsString() << ')';
Anders Carlssonf9bcf012007-08-22 15:14:15 +00001137}
1138
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00001139void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
Chris Lattner39f34e92008-11-24 04:00:27 +00001140 OS << "@selector(" << Node->getSelector().getAsString() << ')';
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00001141}
1142
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00001143void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
Chris Lattner39f34e92008-11-24 04:00:27 +00001144 OS << "@protocol(" << Node->getProtocol()->getNameAsString() << ')';
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00001145}
1146
Steve Naroff563477d2007-09-18 23:55:05 +00001147void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) {
1148 OS << "[";
Steve Naroff6a8a9a42007-10-02 20:01:56 +00001149 Expr *receiver = Mess->getReceiver();
1150 if (receiver) PrintExpr(receiver);
1151 else OS << Mess->getClassName()->getName();
Ted Kremenekc29efd82008-05-02 17:32:38 +00001152 OS << ' ';
Ted Kremenek97b7f262008-04-16 04:30:16 +00001153 Selector selector = Mess->getSelector();
Steve Naroff6a8a9a42007-10-02 20:01:56 +00001154 if (selector.isUnarySelector()) {
Ted Kremenekc29efd82008-05-02 17:32:38 +00001155 OS << selector.getIdentifierInfoForSlot(0)->getName();
Steve Naroff6a8a9a42007-10-02 20:01:56 +00001156 } else {
1157 for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) {
Ted Kremenekc29efd82008-05-02 17:32:38 +00001158 if (i < selector.getNumArgs()) {
1159 if (i > 0) OS << ' ';
1160 if (selector.getIdentifierInfoForSlot(i))
Chris Lattner39f34e92008-11-24 04:00:27 +00001161 OS << selector.getIdentifierInfoForSlot(i)->getName() << ':';
Ted Kremenekc29efd82008-05-02 17:32:38 +00001162 else
1163 OS << ":";
1164 }
1165 else OS << ", "; // Handle variadic methods.
1166
Steve Naroff6a8a9a42007-10-02 20:01:56 +00001167 PrintExpr(Mess->getArg(i));
1168 }
Steve Naroff563477d2007-09-18 23:55:05 +00001169 }
1170 OS << "]";
1171}
1172
Douglas Gregorcd9b46e2008-11-04 14:56:14 +00001173void StmtPrinter::VisitObjCSuperExpr(ObjCSuperExpr *) {
1174 OS << "super";
1175}
1176
Steve Naroff4eb206b2008-09-03 18:15:37 +00001177void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
Steve Naroff56ee6892008-10-08 17:01:13 +00001178 BlockDecl *BD = Node->getBlockDecl();
Steve Naroff4eb206b2008-09-03 18:15:37 +00001179 OS << "^";
1180
1181 const FunctionType *AFT = Node->getFunctionType();
1182
Douglas Gregor72564e72009-02-26 23:50:07 +00001183 if (isa<FunctionNoProtoType>(AFT)) {
Steve Naroff4eb206b2008-09-03 18:15:37 +00001184 OS << "()";
Douglas Gregor72564e72009-02-26 23:50:07 +00001185 } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) {
Steve Naroff4eb206b2008-09-03 18:15:37 +00001186 OS << '(';
1187 std::string ParamStr;
Steve Naroff56ee6892008-10-08 17:01:13 +00001188 for (BlockDecl::param_iterator AI = BD->param_begin(),
1189 E = BD->param_end(); AI != E; ++AI) {
1190 if (AI != BD->param_begin()) OS << ", ";
Chris Lattner39f34e92008-11-24 04:00:27 +00001191 ParamStr = (*AI)->getNameAsString();
Steve Naroff4eb206b2008-09-03 18:15:37 +00001192 (*AI)->getType().getAsStringInternal(ParamStr);
1193 OS << ParamStr;
1194 }
1195
Douglas Gregor72564e72009-02-26 23:50:07 +00001196 const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001197 if (FT->isVariadic()) {
Steve Naroff56ee6892008-10-08 17:01:13 +00001198 if (!BD->param_empty()) OS << ", ";
Steve Naroff4eb206b2008-09-03 18:15:37 +00001199 OS << "...";
1200 }
1201 OS << ')';
1202 }
1203}
1204
Steve Naroff4eb206b2008-09-03 18:15:37 +00001205void StmtPrinter::VisitBlockDeclRefExpr(BlockDeclRefExpr *Node) {
Chris Lattner39f34e92008-11-24 04:00:27 +00001206 OS << Node->getDecl()->getNameAsString();
Steve Naroff4eb206b2008-09-03 18:15:37 +00001207}
Reid Spencer5f016e22007-07-11 17:01:13 +00001208//===----------------------------------------------------------------------===//
1209// Stmt method implementations
1210//===----------------------------------------------------------------------===//
1211
Chris Lattner6000dac2007-08-08 22:51:59 +00001212void Stmt::dumpPretty() const {
Daniel Dunbar4a77edb2009-03-10 18:00:19 +00001213 printPretty(llvm::errs());
Reid Spencer5f016e22007-07-11 17:01:13 +00001214}
1215
Mike Stump071e4da2009-02-10 20:16:46 +00001216void Stmt::printPretty(llvm::raw_ostream &OS, PrinterHelper* Helper,
1217 unsigned I, bool NoIndent) const {
Reid Spencer5f016e22007-07-11 17:01:13 +00001218 if (this == 0) {
1219 OS << "<NULL>";
1220 return;
1221 }
1222
Mike Stump071e4da2009-02-10 20:16:46 +00001223 StmtPrinter P(OS, Helper, I, NoIndent);
Chris Lattnerc5598cb2007-08-21 04:04:25 +00001224 P.Visit(const_cast<Stmt*>(this));
Reid Spencer5f016e22007-07-11 17:01:13 +00001225}
Ted Kremenek42a509f2007-08-31 21:30:12 +00001226
1227//===----------------------------------------------------------------------===//
1228// PrinterHelper
1229//===----------------------------------------------------------------------===//
1230
1231// Implement virtual destructor.
Gabor Greif84675832007-09-11 15:32:40 +00001232PrinterHelper::~PrinterHelper() {}