blob: 93d10f7aafe0e8672109c1e44d4792ef546aa5ea [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
Benjamin Kramer471c8b42012-07-04 20:19:54 +000015#include "clang/AST/ASTContext.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000016#include "clang/AST/StmtVisitor.h"
Douglas Gregor1a49af92009-01-06 05:10:23 +000017#include "clang/AST/DeclCXX.h"
Ted Kremenek91d1d7a2007-10-17 18:36:42 +000018#include "clang/AST/DeclObjC.h"
Douglas Gregorc7793c72011-01-15 01:15:58 +000019#include "clang/AST/DeclTemplate.h"
Ted Kremenek42a509f2007-08-31 21:30:12 +000020#include "clang/AST/PrettyPrinter.h"
Douglas Gregor8ecdb652010-04-28 22:16:22 +000021#include "clang/AST/Expr.h"
Douglas Gregorab6677e2010-09-08 00:15:04 +000022#include "clang/AST/ExprCXX.h"
Benjamin Kramer8fe83e12012-02-04 13:45:25 +000023#include "llvm/ADT/SmallString.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000024using namespace clang;
25
26//===----------------------------------------------------------------------===//
27// StmtPrinter Visitor
28//===----------------------------------------------------------------------===//
29
30namespace {
Benjamin Kramer770b4a82009-11-28 19:03:38 +000031 class StmtPrinter : public StmtVisitor<StmtPrinter> {
Chris Lattner5f9e2722011-07-23 10:55:15 +000032 raw_ostream &OS;
Reid Spencer5f016e22007-07-11 17:01:13 +000033 unsigned IndentLevel;
Ted Kremenek42a509f2007-08-31 21:30:12 +000034 clang::PrinterHelper* Helper;
Douglas Gregord249e1d1f2009-05-29 20:38:28 +000035 PrintingPolicy Policy;
36
Reid Spencer5f016e22007-07-11 17:01:13 +000037 public:
Richard Smithd1420c62012-08-16 03:56:14 +000038 StmtPrinter(raw_ostream &os, PrinterHelper* helper,
Chris Lattnere4f21422009-06-30 01:26:17 +000039 const PrintingPolicy &Policy,
Douglas Gregord249e1d1f2009-05-29 20:38:28 +000040 unsigned Indentation = 0)
Richard Smithd1420c62012-08-16 03:56:14 +000041 : OS(os), IndentLevel(Indentation), Helper(helper), Policy(Policy) {}
Mike Stump1eb44332009-09-09 15:08:12 +000042
Douglas Gregord249e1d1f2009-05-29 20:38:28 +000043 void PrintStmt(Stmt *S) {
44 PrintStmt(S, Policy.Indentation);
45 }
46
47 void PrintStmt(Stmt *S, int SubIndent) {
Reid Spencer5f016e22007-07-11 17:01:13 +000048 IndentLevel += SubIndent;
49 if (S && isa<Expr>(S)) {
50 // If this is an expr used in a stmt context, indent and newline it.
51 Indent();
Chris Lattnerc5598cb2007-08-21 04:04:25 +000052 Visit(S);
Reid Spencer5f016e22007-07-11 17:01:13 +000053 OS << ";\n";
54 } else if (S) {
Chris Lattnerc5598cb2007-08-21 04:04:25 +000055 Visit(S);
Reid Spencer5f016e22007-07-11 17:01:13 +000056 } else {
57 Indent() << "<<<NULL STATEMENT>>>\n";
58 }
59 IndentLevel -= SubIndent;
60 }
Eli Friedmandb23b152009-05-30 00:19:54 +000061
Reid Spencer5f016e22007-07-11 17:01:13 +000062 void PrintRawCompoundStmt(CompoundStmt *S);
63 void PrintRawDecl(Decl *D);
Ted Kremenekecd64c52008-10-06 18:39:36 +000064 void PrintRawDeclStmt(DeclStmt *S);
Reid Spencer5f016e22007-07-11 17:01:13 +000065 void PrintRawIfStmt(IfStmt *If);
Sebastian Redl8351da02008-12-22 21:35:02 +000066 void PrintRawCXXCatchStmt(CXXCatchStmt *Catch);
Peter Collingbourned64e2372011-02-08 21:17:54 +000067 void PrintCallArgs(CallExpr *E);
John Wiegley28bbe4b2011-04-28 01:08:34 +000068 void PrintRawSEHExceptHandler(SEHExceptStmt *S);
69 void PrintRawSEHFinallyStmt(SEHFinallyStmt *S);
Mike Stump1eb44332009-09-09 15:08:12 +000070
Reid Spencer5f016e22007-07-11 17:01:13 +000071 void PrintExpr(Expr *E) {
72 if (E)
Chris Lattnerc5598cb2007-08-21 04:04:25 +000073 Visit(E);
Reid Spencer5f016e22007-07-11 17:01:13 +000074 else
75 OS << "<null expr>";
76 }
Mike Stump1eb44332009-09-09 15:08:12 +000077
Chris Lattner5f9e2722011-07-23 10:55:15 +000078 raw_ostream &Indent(int Delta = 0) {
Douglas Gregord249e1d1f2009-05-29 20:38:28 +000079 for (int i = 0, e = IndentLevel+Delta; i < e; ++i)
80 OS << " ";
Reid Spencer5f016e22007-07-11 17:01:13 +000081 return OS;
82 }
Mike Stump1eb44332009-09-09 15:08:12 +000083
Mike Stump1eb44332009-09-09 15:08:12 +000084 void Visit(Stmt* S) {
Ted Kremenek42a509f2007-08-31 21:30:12 +000085 if (Helper && Helper->handledStmt(S,OS))
86 return;
87 else StmtVisitor<StmtPrinter>::Visit(S);
88 }
Argyrios Kyrtzidis78e4cc72010-08-15 01:15:33 +000089
Chandler Carruth61e38282010-10-23 08:21:37 +000090 void VisitStmt(Stmt *Node) LLVM_ATTRIBUTE_UNUSED {
Argyrios Kyrtzidis78e4cc72010-08-15 01:15:33 +000091 Indent() << "<<unknown stmt type>>\n";
92 }
Chandler Carruth61e38282010-10-23 08:21:37 +000093 void VisitExpr(Expr *Node) LLVM_ATTRIBUTE_UNUSED {
Argyrios Kyrtzidis78e4cc72010-08-15 01:15:33 +000094 OS << "<<unknown expr type>>";
95 }
96 void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
Mike Stump1eb44332009-09-09 15:08:12 +000097
Argyrios Kyrtzidis78e4cc72010-08-15 01:15:33 +000098#define ABSTRACT_STMT(CLASS)
Douglas Gregorf2cad862008-11-14 12:46:07 +000099#define STMT(CLASS, PARENT) \
Chris Lattnerc5598cb2007-08-21 04:04:25 +0000100 void Visit##CLASS(CLASS *Node);
Sean Hunt4bfe1962010-05-05 15:24:00 +0000101#include "clang/AST/StmtNodes.inc"
Reid Spencer5f016e22007-07-11 17:01:13 +0000102 };
103}
104
105//===----------------------------------------------------------------------===//
106// Stmt printing methods.
107//===----------------------------------------------------------------------===//
108
Reid Spencer5f016e22007-07-11 17:01:13 +0000109/// PrintRawCompoundStmt - Print a compound stmt without indenting the {, and
110/// with no newline after the }.
111void StmtPrinter::PrintRawCompoundStmt(CompoundStmt *Node) {
112 OS << "{\n";
113 for (CompoundStmt::body_iterator I = Node->body_begin(), E = Node->body_end();
114 I != E; ++I)
115 PrintStmt(*I);
Mike Stump1eb44332009-09-09 15:08:12 +0000116
Reid Spencer5f016e22007-07-11 17:01:13 +0000117 Indent() << "}";
118}
119
120void StmtPrinter::PrintRawDecl(Decl *D) {
Argyrios Kyrtzidisf1d60ea2009-06-30 02:35:04 +0000121 D->print(OS, Policy, IndentLevel);
Mike Stump071e4da2009-02-10 20:16:46 +0000122}
123
Ted Kremenekecd64c52008-10-06 18:39:36 +0000124void StmtPrinter::PrintRawDeclStmt(DeclStmt *S) {
Eli Friedmandb23b152009-05-30 00:19:54 +0000125 DeclStmt::decl_iterator Begin = S->decl_begin(), End = S->decl_end();
Chris Lattner5f9e2722011-07-23 10:55:15 +0000126 SmallVector<Decl*, 2> Decls;
Mike Stump1eb44332009-09-09 15:08:12 +0000127 for ( ; Begin != End; ++Begin)
Eli Friedman42f42c02009-05-30 04:20:30 +0000128 Decls.push_back(*Begin);
Eli Friedmandb23b152009-05-30 00:19:54 +0000129
Argyrios Kyrtzidisf1d60ea2009-06-30 02:35:04 +0000130 Decl::printGroup(Decls.data(), Decls.size(), OS, Policy, IndentLevel);
Ted Kremenekecd64c52008-10-06 18:39:36 +0000131}
Reid Spencer5f016e22007-07-11 17:01:13 +0000132
133void StmtPrinter::VisitNullStmt(NullStmt *Node) {
134 Indent() << ";\n";
135}
136
137void StmtPrinter::VisitDeclStmt(DeclStmt *Node) {
Eli Friedmandb23b152009-05-30 00:19:54 +0000138 Indent();
139 PrintRawDeclStmt(Node);
140 OS << ";\n";
Reid Spencer5f016e22007-07-11 17:01:13 +0000141}
142
143void StmtPrinter::VisitCompoundStmt(CompoundStmt *Node) {
144 Indent();
145 PrintRawCompoundStmt(Node);
146 OS << "\n";
147}
148
149void StmtPrinter::VisitCaseStmt(CaseStmt *Node) {
150 Indent(-1) << "case ";
151 PrintExpr(Node->getLHS());
152 if (Node->getRHS()) {
153 OS << " ... ";
154 PrintExpr(Node->getRHS());
155 }
156 OS << ":\n";
Mike Stump1eb44332009-09-09 15:08:12 +0000157
Reid Spencer5f016e22007-07-11 17:01:13 +0000158 PrintStmt(Node->getSubStmt(), 0);
159}
160
161void StmtPrinter::VisitDefaultStmt(DefaultStmt *Node) {
162 Indent(-1) << "default:\n";
163 PrintStmt(Node->getSubStmt(), 0);
164}
165
166void StmtPrinter::VisitLabelStmt(LabelStmt *Node) {
167 Indent(-1) << Node->getName() << ":\n";
168 PrintStmt(Node->getSubStmt(), 0);
169}
170
Richard Smith534986f2012-04-14 00:33:13 +0000171void StmtPrinter::VisitAttributedStmt(AttributedStmt *Node) {
172 OS << "[[";
173 bool first = true;
Alexander Kornienko49908902012-07-09 10:04:07 +0000174 for (ArrayRef<const Attr*>::iterator it = Node->getAttrs().begin(),
175 end = Node->getAttrs().end();
176 it != end; ++it) {
Richard Smith534986f2012-04-14 00:33:13 +0000177 if (!first) {
178 OS << ", ";
179 first = false;
180 }
181 // TODO: check this
Richard Smith0dae7292012-08-16 02:43:29 +0000182 (*it)->printPretty(OS, Policy);
Richard Smith534986f2012-04-14 00:33:13 +0000183 }
184 OS << "]] ";
185 PrintStmt(Node->getSubStmt(), 0);
186}
187
Reid Spencer5f016e22007-07-11 17:01:13 +0000188void StmtPrinter::PrintRawIfStmt(IfStmt *If) {
Sebastian Redlbfee9b22009-02-07 20:05:48 +0000189 OS << "if (";
Reid Spencer5f016e22007-07-11 17:01:13 +0000190 PrintExpr(If->getCond());
Sebastian Redlbfee9b22009-02-07 20:05:48 +0000191 OS << ')';
Mike Stump1eb44332009-09-09 15:08:12 +0000192
Reid Spencer5f016e22007-07-11 17:01:13 +0000193 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(If->getThen())) {
194 OS << ' ';
195 PrintRawCompoundStmt(CS);
196 OS << (If->getElse() ? ' ' : '\n');
197 } else {
198 OS << '\n';
199 PrintStmt(If->getThen());
200 if (If->getElse()) Indent();
201 }
Mike Stump1eb44332009-09-09 15:08:12 +0000202
Reid Spencer5f016e22007-07-11 17:01:13 +0000203 if (Stmt *Else = If->getElse()) {
204 OS << "else";
Mike Stump1eb44332009-09-09 15:08:12 +0000205
Reid Spencer5f016e22007-07-11 17:01:13 +0000206 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Else)) {
207 OS << ' ';
208 PrintRawCompoundStmt(CS);
209 OS << '\n';
210 } else if (IfStmt *ElseIf = dyn_cast<IfStmt>(Else)) {
211 OS << ' ';
212 PrintRawIfStmt(ElseIf);
213 } else {
214 OS << '\n';
215 PrintStmt(If->getElse());
216 }
217 }
218}
219
220void StmtPrinter::VisitIfStmt(IfStmt *If) {
221 Indent();
222 PrintRawIfStmt(If);
223}
224
225void StmtPrinter::VisitSwitchStmt(SwitchStmt *Node) {
226 Indent() << "switch (";
227 PrintExpr(Node->getCond());
228 OS << ")";
Mike Stump1eb44332009-09-09 15:08:12 +0000229
Reid Spencer5f016e22007-07-11 17:01:13 +0000230 // Pretty print compoundstmt bodies (very common).
231 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
232 OS << " ";
233 PrintRawCompoundStmt(CS);
234 OS << "\n";
235 } else {
236 OS << "\n";
237 PrintStmt(Node->getBody());
238 }
239}
240
241void StmtPrinter::VisitWhileStmt(WhileStmt *Node) {
242 Indent() << "while (";
243 PrintExpr(Node->getCond());
244 OS << ")\n";
245 PrintStmt(Node->getBody());
246}
247
248void StmtPrinter::VisitDoStmt(DoStmt *Node) {
Chris Lattner8bdcc472007-09-15 21:49:37 +0000249 Indent() << "do ";
250 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
251 PrintRawCompoundStmt(CS);
252 OS << " ";
253 } else {
254 OS << "\n";
255 PrintStmt(Node->getBody());
256 Indent();
257 }
Mike Stump1eb44332009-09-09 15:08:12 +0000258
Eli Friedmanb3e22962009-05-17 01:05:34 +0000259 OS << "while (";
Reid Spencer5f016e22007-07-11 17:01:13 +0000260 PrintExpr(Node->getCond());
Eli Friedmanb3e22962009-05-17 01:05:34 +0000261 OS << ");\n";
Reid Spencer5f016e22007-07-11 17:01:13 +0000262}
263
264void StmtPrinter::VisitForStmt(ForStmt *Node) {
265 Indent() << "for (";
266 if (Node->getInit()) {
267 if (DeclStmt *DS = dyn_cast<DeclStmt>(Node->getInit()))
Ted Kremenekecd64c52008-10-06 18:39:36 +0000268 PrintRawDeclStmt(DS);
Reid Spencer5f016e22007-07-11 17:01:13 +0000269 else
270 PrintExpr(cast<Expr>(Node->getInit()));
271 }
Chris Lattner8bdcc472007-09-15 21:49:37 +0000272 OS << ";";
273 if (Node->getCond()) {
274 OS << " ";
Reid Spencer5f016e22007-07-11 17:01:13 +0000275 PrintExpr(Node->getCond());
Chris Lattner8bdcc472007-09-15 21:49:37 +0000276 }
277 OS << ";";
278 if (Node->getInc()) {
279 OS << " ";
Reid Spencer5f016e22007-07-11 17:01:13 +0000280 PrintExpr(Node->getInc());
Chris Lattner8bdcc472007-09-15 21:49:37 +0000281 }
282 OS << ") ";
Mike Stump1eb44332009-09-09 15:08:12 +0000283
Chris Lattner8bdcc472007-09-15 21:49:37 +0000284 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
285 PrintRawCompoundStmt(CS);
286 OS << "\n";
287 } else {
288 OS << "\n";
289 PrintStmt(Node->getBody());
290 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000291}
292
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000293void StmtPrinter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *Node) {
Fariborz Jahanian0196cab2008-01-02 22:54:34 +0000294 Indent() << "for (";
295 if (DeclStmt *DS = dyn_cast<DeclStmt>(Node->getElement()))
Ted Kremenekecd64c52008-10-06 18:39:36 +0000296 PrintRawDeclStmt(DS);
Fariborz Jahanian0196cab2008-01-02 22:54:34 +0000297 else
298 PrintExpr(cast<Expr>(Node->getElement()));
299 OS << " in ";
300 PrintExpr(Node->getCollection());
301 OS << ") ";
Mike Stump1eb44332009-09-09 15:08:12 +0000302
Fariborz Jahanian0196cab2008-01-02 22:54:34 +0000303 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
304 PrintRawCompoundStmt(CS);
305 OS << "\n";
306 } else {
307 OS << "\n";
308 PrintStmt(Node->getBody());
309 }
310}
311
Richard Smithad762fc2011-04-14 22:09:26 +0000312void StmtPrinter::VisitCXXForRangeStmt(CXXForRangeStmt *Node) {
313 Indent() << "for (";
314 PrintingPolicy SubPolicy(Policy);
315 SubPolicy.SuppressInitializers = true;
316 Node->getLoopVariable()->print(OS, SubPolicy, IndentLevel);
317 OS << " : ";
318 PrintExpr(Node->getRangeInit());
319 OS << ") {\n";
320 PrintStmt(Node->getBody());
321 Indent() << "}\n";
322}
323
Douglas Gregorba0513d2011-10-25 01:33:02 +0000324void StmtPrinter::VisitMSDependentExistsStmt(MSDependentExistsStmt *Node) {
325 Indent();
326 if (Node->isIfExists())
327 OS << "__if_exists (";
328 else
329 OS << "__if_not_exists (";
330
331 if (NestedNameSpecifier *Qualifier
332 = Node->getQualifierLoc().getNestedNameSpecifier())
333 Qualifier->print(OS, Policy);
334
335 OS << Node->getNameInfo() << ") ";
336
337 PrintRawCompoundStmt(Node->getSubStmt());
338}
339
Reid Spencer5f016e22007-07-11 17:01:13 +0000340void StmtPrinter::VisitGotoStmt(GotoStmt *Node) {
341 Indent() << "goto " << Node->getLabel()->getName() << ";\n";
342}
343
344void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) {
345 Indent() << "goto *";
346 PrintExpr(Node->getTarget());
347 OS << ";\n";
348}
349
350void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) {
351 Indent() << "continue;\n";
352}
353
354void StmtPrinter::VisitBreakStmt(BreakStmt *Node) {
355 Indent() << "break;\n";
356}
357
358
359void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) {
360 Indent() << "return";
361 if (Node->getRetValue()) {
362 OS << " ";
363 PrintExpr(Node->getRetValue());
364 }
365 OS << ";\n";
366}
367
Chris Lattnerfe795952007-10-29 04:04:16 +0000368
Chad Rosierdf5faf52012-08-25 00:11:56 +0000369void StmtPrinter::VisitGCCAsmStmt(GCCAsmStmt *Node) {
Anders Carlsson39c47b52007-11-23 23:12:25 +0000370 Indent() << "asm ";
Mike Stump1eb44332009-09-09 15:08:12 +0000371
Anders Carlsson39c47b52007-11-23 23:12:25 +0000372 if (Node->isVolatile())
373 OS << "volatile ";
Mike Stump1eb44332009-09-09 15:08:12 +0000374
Anders Carlsson39c47b52007-11-23 23:12:25 +0000375 OS << "(";
Anders Carlsson6a0ef4b2007-11-20 19:21:03 +0000376 VisitStringLiteral(Node->getAsmString());
Mike Stump1eb44332009-09-09 15:08:12 +0000377
Anders Carlssonb235fc22007-11-22 01:36:19 +0000378 // Outputs
379 if (Node->getNumOutputs() != 0 || Node->getNumInputs() != 0 ||
380 Node->getNumClobbers() != 0)
381 OS << " : ";
Mike Stump1eb44332009-09-09 15:08:12 +0000382
Anders Carlssonb235fc22007-11-22 01:36:19 +0000383 for (unsigned i = 0, e = Node->getNumOutputs(); i != e; ++i) {
384 if (i != 0)
385 OS << ", ";
Mike Stump1eb44332009-09-09 15:08:12 +0000386
Anders Carlssonb235fc22007-11-22 01:36:19 +0000387 if (!Node->getOutputName(i).empty()) {
388 OS << '[';
389 OS << Node->getOutputName(i);
390 OS << "] ";
391 }
Mike Stump1eb44332009-09-09 15:08:12 +0000392
Chris Lattnerb3277932009-03-10 04:59:06 +0000393 VisitStringLiteral(Node->getOutputConstraintLiteral(i));
Anders Carlssonb235fc22007-11-22 01:36:19 +0000394 OS << " ";
395 Visit(Node->getOutputExpr(i));
396 }
Mike Stump1eb44332009-09-09 15:08:12 +0000397
Anders Carlssonb235fc22007-11-22 01:36:19 +0000398 // Inputs
399 if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0)
400 OS << " : ";
Mike Stump1eb44332009-09-09 15:08:12 +0000401
Anders Carlssonb235fc22007-11-22 01:36:19 +0000402 for (unsigned i = 0, e = Node->getNumInputs(); i != e; ++i) {
403 if (i != 0)
404 OS << ", ";
Mike Stump1eb44332009-09-09 15:08:12 +0000405
Anders Carlssonb235fc22007-11-22 01:36:19 +0000406 if (!Node->getInputName(i).empty()) {
407 OS << '[';
408 OS << Node->getInputName(i);
409 OS << "] ";
410 }
Mike Stump1eb44332009-09-09 15:08:12 +0000411
Chris Lattnerb3277932009-03-10 04:59:06 +0000412 VisitStringLiteral(Node->getInputConstraintLiteral(i));
Anders Carlssonb235fc22007-11-22 01:36:19 +0000413 OS << " ";
414 Visit(Node->getInputExpr(i));
415 }
Mike Stump1eb44332009-09-09 15:08:12 +0000416
Anders Carlssonb235fc22007-11-22 01:36:19 +0000417 // Clobbers
418 if (Node->getNumClobbers() != 0)
419 OS << " : ";
Mike Stump1eb44332009-09-09 15:08:12 +0000420
Anders Carlssonb235fc22007-11-22 01:36:19 +0000421 for (unsigned i = 0, e = Node->getNumClobbers(); i != e; ++i) {
422 if (i != 0)
423 OS << ", ";
Mike Stump1eb44332009-09-09 15:08:12 +0000424
Chad Rosier5c7f5942012-08-27 23:28:41 +0000425 VisitStringLiteral(Node->getClobberStringLiteral(i));
Anders Carlssonb235fc22007-11-22 01:36:19 +0000426 }
Mike Stump1eb44332009-09-09 15:08:12 +0000427
Anders Carlsson6a0ef4b2007-11-20 19:21:03 +0000428 OS << ");\n";
Chris Lattnerfe795952007-10-29 04:04:16 +0000429}
430
Chad Rosier8cd64b42012-06-11 20:47:18 +0000431void StmtPrinter::VisitMSAsmStmt(MSAsmStmt *Node) {
432 // FIXME: Implement MS style inline asm statement printer.
Chad Rosier7bd092b2012-08-15 16:53:30 +0000433 Indent() << "__asm ";
434 if (Node->hasBraces())
435 OS << "{\n";
436 OS << *(Node->getAsmString()) << "\n";
437 if (Node->hasBraces())
438 Indent() << "}\n";
Chad Rosier8cd64b42012-06-11 20:47:18 +0000439}
440
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000441void StmtPrinter::VisitObjCAtTryStmt(ObjCAtTryStmt *Node) {
Fariborz Jahanian7794cb82007-11-02 18:16:07 +0000442 Indent() << "@try";
443 if (CompoundStmt *TS = dyn_cast<CompoundStmt>(Node->getTryBody())) {
444 PrintRawCompoundStmt(TS);
445 OS << "\n";
446 }
Mike Stump1eb44332009-09-09 15:08:12 +0000447
Douglas Gregor8f5e3dd2010-04-23 22:50:49 +0000448 for (unsigned I = 0, N = Node->getNumCatchStmts(); I != N; ++I) {
449 ObjCAtCatchStmt *catchStmt = Node->getCatchStmt(I);
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 << ")";
Mike Stump1eb44332009-09-09 15:08:12 +0000456 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(catchStmt->getCatchBody())) {
457 PrintRawCompoundStmt(CS);
458 OS << "\n";
459 }
Fariborz Jahanian7794cb82007-11-02 18:16:07 +0000460 }
Mike Stump1eb44332009-09-09 15:08:12 +0000461
462 if (ObjCAtFinallyStmt *FS = static_cast<ObjCAtFinallyStmt *>(
463 Node->getFinallyStmt())) {
Fariborz Jahanian1e7eab42007-11-07 00:46:42 +0000464 Indent() << "@finally";
465 PrintRawCompoundStmt(dyn_cast<CompoundStmt>(FS->getFinallyBody()));
Fariborz Jahanian7794cb82007-11-02 18:16:07 +0000466 OS << "\n";
Mike Stump1eb44332009-09-09 15:08:12 +0000467 }
Fariborz Jahanianb210bd02007-11-01 21:12:44 +0000468}
469
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000470void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) {
Fariborz Jahanianb210bd02007-11-01 21:12:44 +0000471}
472
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000473void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) {
Fariborz Jahanianb210bd02007-11-01 21:12:44 +0000474 Indent() << "@catch (...) { /* todo */ } \n";
475}
476
Fariborz Jahanian78a677b2008-01-30 17:38:29 +0000477void StmtPrinter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *Node) {
Fariborz Jahanian39f8f152007-11-07 02:00:49 +0000478 Indent() << "@throw";
479 if (Node->getThrowExpr()) {
480 OS << " ";
481 PrintExpr(Node->getThrowExpr());
482 }
483 OS << ";\n";
484}
485
Fariborz Jahanian78a677b2008-01-30 17:38:29 +0000486void StmtPrinter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *Node) {
Fariborz Jahanianc385c902008-01-29 18:21:32 +0000487 Indent() << "@synchronized (";
488 PrintExpr(Node->getSynchExpr());
489 OS << ")";
Fariborz Jahanian78a677b2008-01-30 17:38:29 +0000490 PrintRawCompoundStmt(Node->getSynchBody());
491 OS << "\n";
Fariborz Jahanianc385c902008-01-29 18:21:32 +0000492}
493
John McCallf85e1932011-06-15 23:02:42 +0000494void StmtPrinter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *Node) {
495 Indent() << "@autoreleasepool";
496 PrintRawCompoundStmt(dyn_cast<CompoundStmt>(Node->getSubStmt()));
497 OS << "\n";
498}
499
Sebastian Redl8351da02008-12-22 21:35:02 +0000500void StmtPrinter::PrintRawCXXCatchStmt(CXXCatchStmt *Node) {
501 OS << "catch (";
Sebastian Redl4b07b292008-12-22 19:15:10 +0000502 if (Decl *ExDecl = Node->getExceptionDecl())
503 PrintRawDecl(ExDecl);
504 else
505 OS << "...";
506 OS << ") ";
507 PrintRawCompoundStmt(cast<CompoundStmt>(Node->getHandlerBlock()));
Sebastian Redl8351da02008-12-22 21:35:02 +0000508}
509
510void StmtPrinter::VisitCXXCatchStmt(CXXCatchStmt *Node) {
511 Indent();
512 PrintRawCXXCatchStmt(Node);
513 OS << "\n";
514}
515
516void StmtPrinter::VisitCXXTryStmt(CXXTryStmt *Node) {
517 Indent() << "try ";
518 PrintRawCompoundStmt(Node->getTryBlock());
Mike Stump1eb44332009-09-09 15:08:12 +0000519 for (unsigned i = 0, e = Node->getNumHandlers(); i < e; ++i) {
Sebastian Redl8351da02008-12-22 21:35:02 +0000520 OS << " ";
521 PrintRawCXXCatchStmt(Node->getHandler(i));
522 }
Sebastian Redl4b07b292008-12-22 19:15:10 +0000523 OS << "\n";
524}
525
John Wiegley28bbe4b2011-04-28 01:08:34 +0000526void StmtPrinter::VisitSEHTryStmt(SEHTryStmt *Node) {
527 Indent() << (Node->getIsCXXTry() ? "try " : "__try ");
528 PrintRawCompoundStmt(Node->getTryBlock());
529 SEHExceptStmt *E = Node->getExceptHandler();
530 SEHFinallyStmt *F = Node->getFinallyHandler();
531 if(E)
532 PrintRawSEHExceptHandler(E);
533 else {
534 assert(F && "Must have a finally block...");
535 PrintRawSEHFinallyStmt(F);
536 }
537 OS << "\n";
538}
539
540void StmtPrinter::PrintRawSEHFinallyStmt(SEHFinallyStmt *Node) {
541 OS << "__finally ";
542 PrintRawCompoundStmt(Node->getBlock());
543 OS << "\n";
544}
545
546void StmtPrinter::PrintRawSEHExceptHandler(SEHExceptStmt *Node) {
547 OS << "__except (";
548 VisitExpr(Node->getFilterExpr());
Joao Matos568ba872012-09-04 17:49:35 +0000549 OS << ")\n";
John Wiegley28bbe4b2011-04-28 01:08:34 +0000550 PrintRawCompoundStmt(Node->getBlock());
551 OS << "\n";
552}
553
554void StmtPrinter::VisitSEHExceptStmt(SEHExceptStmt *Node) {
555 Indent();
556 PrintRawSEHExceptHandler(Node);
557 OS << "\n";
558}
559
560void StmtPrinter::VisitSEHFinallyStmt(SEHFinallyStmt *Node) {
561 Indent();
562 PrintRawSEHFinallyStmt(Node);
563 OS << "\n";
564}
565
Reid Spencer5f016e22007-07-11 17:01:13 +0000566//===----------------------------------------------------------------------===//
567// Expr printing methods.
568//===----------------------------------------------------------------------===//
569
Reid Spencer5f016e22007-07-11 17:01:13 +0000570void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
Douglas Gregora2813ce2009-10-23 18:54:35 +0000571 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
572 Qualifier->print(OS, Policy);
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000573 if (Node->hasTemplateKeyword())
574 OS << "template ";
Abramo Bagnara25777432010-08-11 22:01:17 +0000575 OS << Node->getNameInfo();
John McCall096832c2010-08-19 23:49:38 +0000576 if (Node->hasExplicitTemplateArgs())
Douglas Gregora2813ce2009-10-23 18:54:35 +0000577 OS << TemplateSpecializationType::PrintTemplateArgumentList(
578 Node->getTemplateArgs(),
579 Node->getNumTemplateArgs(),
Sean Huntc3021132010-05-05 15:23:54 +0000580 Policy);
Douglas Gregor1a49af92009-01-06 05:10:23 +0000581}
582
John McCall865d4472009-11-19 22:55:06 +0000583void StmtPrinter::VisitDependentScopeDeclRefExpr(
584 DependentScopeDeclRefExpr *Node) {
Axel Naumann274f83c2011-01-24 15:44:00 +0000585 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
586 Qualifier->print(OS, Policy);
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000587 if (Node->hasTemplateKeyword())
588 OS << "template ";
Abramo Bagnara25777432010-08-11 22:01:17 +0000589 OS << Node->getNameInfo();
John McCallf7a1a742009-11-24 19:00:30 +0000590 if (Node->hasExplicitTemplateArgs())
591 OS << TemplateSpecializationType::PrintTemplateArgumentList(
592 Node->getTemplateArgs(),
593 Node->getNumTemplateArgs(),
594 Policy);
Douglas Gregor5953d8b2009-03-19 17:26:29 +0000595}
596
John McCallba135432009-11-21 08:51:07 +0000597void StmtPrinter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) {
Douglas Gregoredce4dd2009-06-30 22:34:41 +0000598 if (Node->getQualifier())
599 Node->getQualifier()->print(OS, Policy);
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000600 if (Node->hasTemplateKeyword())
601 OS << "template ";
Abramo Bagnara25777432010-08-11 22:01:17 +0000602 OS << Node->getNameInfo();
John McCallf7a1a742009-11-24 19:00:30 +0000603 if (Node->hasExplicitTemplateArgs())
604 OS << TemplateSpecializationType::PrintTemplateArgumentList(
605 Node->getTemplateArgs(),
Douglas Gregoredce4dd2009-06-30 22:34:41 +0000606 Node->getNumTemplateArgs(),
John McCallf7a1a742009-11-24 19:00:30 +0000607 Policy);
Douglas Gregoredce4dd2009-06-30 22:34:41 +0000608}
609
Steve Naroff7779db42007-11-12 14:29:37 +0000610void StmtPrinter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
Fariborz Jahanian232220c2007-11-12 22:29:28 +0000611 if (Node->getBase()) {
612 PrintExpr(Node->getBase());
613 OS << (Node->isArrow() ? "->" : ".");
614 }
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000615 OS << *Node->getDecl();
Steve Naroff7779db42007-11-12 14:29:37 +0000616}
617
Steve Naroffae784072008-05-30 00:40:33 +0000618void StmtPrinter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
Fariborz Jahanian8ac2d442010-10-14 16:04:05 +0000619 if (Node->isSuperReceiver())
620 OS << "super.";
621 else if (Node->getBase()) {
Steve Naroffae784072008-05-30 00:40:33 +0000622 PrintExpr(Node->getBase());
623 OS << ".";
624 }
Fariborz Jahanian8ac2d442010-10-14 16:04:05 +0000625
John McCall12f78a62010-12-02 01:19:52 +0000626 if (Node->isImplicitProperty())
627 OS << Node->getImplicitPropertyGetter()->getSelector().getAsString();
628 else
629 OS << Node->getExplicitProperty()->getName();
Fariborz Jahanian5daf5702008-11-22 18:39:36 +0000630}
631
Ted Kremenekebcb57a2012-03-06 20:05:56 +0000632void StmtPrinter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *Node) {
633
634 PrintExpr(Node->getBaseExpr());
635 OS << "[";
636 PrintExpr(Node->getKeyExpr());
637 OS << "]";
638}
639
Chris Lattnerd9f69102008-08-10 01:53:14 +0000640void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) {
Anders Carlsson22742662007-07-21 05:21:51 +0000641 switch (Node->getIdentType()) {
642 default:
David Blaikieb219cfc2011-09-23 05:06:16 +0000643 llvm_unreachable("unknown case");
Chris Lattnerd9f69102008-08-10 01:53:14 +0000644 case PredefinedExpr::Func:
Anders Carlsson22742662007-07-21 05:21:51 +0000645 OS << "__func__";
646 break;
Chris Lattnerd9f69102008-08-10 01:53:14 +0000647 case PredefinedExpr::Function:
Anders Carlsson22742662007-07-21 05:21:51 +0000648 OS << "__FUNCTION__";
649 break;
Nico Weber28ad0632012-06-23 02:07:59 +0000650 case PredefinedExpr::LFunction:
651 OS << "L__FUNCTION__";
652 break;
Chris Lattnerd9f69102008-08-10 01:53:14 +0000653 case PredefinedExpr::PrettyFunction:
Anders Carlsson22742662007-07-21 05:21:51 +0000654 OS << "__PRETTY_FUNCTION__";
655 break;
656 }
657}
658
Reid Spencer5f016e22007-07-11 17:01:13 +0000659void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) {
Chris Lattnerb0a721a2007-07-13 05:18:11 +0000660 unsigned value = Node->getValue();
Douglas Gregor5cee1192011-07-27 05:40:30 +0000661
662 switch (Node->getKind()) {
663 case CharacterLiteral::Ascii: break; // no prefix.
664 case CharacterLiteral::Wide: OS << 'L'; break;
665 case CharacterLiteral::UTF16: OS << 'u'; break;
666 case CharacterLiteral::UTF32: OS << 'U'; break;
667 }
668
Chris Lattner8bf9f072007-07-13 23:58:20 +0000669 switch (value) {
670 case '\\':
671 OS << "'\\\\'";
672 break;
673 case '\'':
674 OS << "'\\''";
675 break;
676 case '\a':
677 // TODO: K&R: the meaning of '\\a' is different in traditional C
678 OS << "'\\a'";
679 break;
680 case '\b':
681 OS << "'\\b'";
682 break;
683 // Nonstandard escape sequence.
684 /*case '\e':
685 OS << "'\\e'";
686 break;*/
687 case '\f':
688 OS << "'\\f'";
689 break;
690 case '\n':
691 OS << "'\\n'";
692 break;
693 case '\r':
694 OS << "'\\r'";
695 break;
696 case '\t':
697 OS << "'\\t'";
698 break;
699 case '\v':
700 OS << "'\\v'";
701 break;
702 default:
Ted Kremenek471733d2008-02-23 00:52:04 +0000703 if (value < 256 && isprint(value)) {
Chris Lattner8bf9f072007-07-13 23:58:20 +0000704 OS << "'" << (char)value << "'";
705 } else if (value < 256) {
Benjamin Kramer8fe83e12012-02-04 13:45:25 +0000706 OS << "'\\x";
707 OS.write_hex(value) << "'";
Chris Lattner8bf9f072007-07-13 23:58:20 +0000708 } else {
709 // FIXME what to really do here?
710 OS << value;
711 }
Chris Lattnerb0a721a2007-07-13 05:18:11 +0000712 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000713}
714
715void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) {
716 bool isSigned = Node->getType()->isSignedIntegerType();
717 OS << Node->getValue().toString(10, isSigned);
Mike Stump1eb44332009-09-09 15:08:12 +0000718
Reid Spencer5f016e22007-07-11 17:01:13 +0000719 // Emit suffixes. Integer literals are always a builtin integer type.
John McCall183700f2009-09-21 23:43:11 +0000720 switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
David Blaikieb219cfc2011-09-23 05:06:16 +0000721 default: llvm_unreachable("Unexpected type for integer literal!");
Richard Trieu11cbe2a2011-11-07 18:40:31 +0000722 // FIXME: The Short and UShort cases are to handle cases where a short
723 // integeral literal is formed during template instantiation. They should
724 // be removed when template instantiation no longer needs integer literals.
725 case BuiltinType::Short:
726 case BuiltinType::UShort:
Reid Spencer5f016e22007-07-11 17:01:13 +0000727 case BuiltinType::Int: break; // no suffix.
728 case BuiltinType::UInt: OS << 'U'; break;
729 case BuiltinType::Long: OS << 'L'; break;
730 case BuiltinType::ULong: OS << "UL"; break;
731 case BuiltinType::LongLong: OS << "LL"; break;
732 case BuiltinType::ULongLong: OS << "ULL"; break;
Richard Trieu11cbe2a2011-11-07 18:40:31 +0000733 case BuiltinType::Int128: OS << "i128"; break;
734 case BuiltinType::UInt128: OS << "Ui128"; break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000735 }
736}
Benjamin Kramera0a3c902012-09-20 14:07:17 +0000737
738static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node,
739 bool PrintSuffix) {
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000740 SmallString<16> Str;
Eli Friedmanb3909212011-10-05 20:32:03 +0000741 Node->getValue().toString(Str);
742 OS << Str;
Benjamin Kramera0a3c902012-09-20 14:07:17 +0000743 if (Str.find_first_not_of("-0123456789") == StringRef::npos)
744 OS << '.'; // Trailing dot in order to separate from ints.
745
746 if (!PrintSuffix)
747 return;
748
749 // Emit suffixes. Float literals are always a builtin float type.
750 switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
751 default: llvm_unreachable("Unexpected type for float literal!");
752 case BuiltinType::Half: break; // FIXME: suffix?
753 case BuiltinType::Double: break; // no suffix.
754 case BuiltinType::Float: OS << 'F'; break;
755 case BuiltinType::LongDouble: OS << 'L'; break;
756 }
757}
758
759void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) {
760 PrintFloatingLiteral(OS, Node, /*PrintSuffix=*/true);
Reid Spencer5f016e22007-07-11 17:01:13 +0000761}
Chris Lattner5d661452007-08-26 03:42:43 +0000762
763void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) {
764 PrintExpr(Node->getSubExpr());
765 OS << "i";
766}
767
Reid Spencer5f016e22007-07-11 17:01:13 +0000768void StmtPrinter::VisitStringLiteral(StringLiteral *Str) {
Richard Trieu8ab09da2012-06-13 20:25:24 +0000769 Str->outputString(OS);
Reid Spencer5f016e22007-07-11 17:01:13 +0000770}
771void StmtPrinter::VisitParenExpr(ParenExpr *Node) {
772 OS << "(";
773 PrintExpr(Node->getSubExpr());
774 OS << ")";
775}
776void StmtPrinter::VisitUnaryOperator(UnaryOperator *Node) {
Chris Lattner296bf192007-08-23 21:46:40 +0000777 if (!Node->isPostfix()) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000778 OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
Mike Stump1eb44332009-09-09 15:08:12 +0000779
Eli Friedman7df71ac2009-06-14 22:39:26 +0000780 // Print a space if this is an "identifier operator" like __real, or if
781 // it might be concatenated incorrectly like '+'.
Chris Lattner296bf192007-08-23 21:46:40 +0000782 switch (Node->getOpcode()) {
783 default: break;
John McCall2de56d12010-08-25 11:45:40 +0000784 case UO_Real:
785 case UO_Imag:
786 case UO_Extension:
Chris Lattner296bf192007-08-23 21:46:40 +0000787 OS << ' ';
788 break;
John McCall2de56d12010-08-25 11:45:40 +0000789 case UO_Plus:
790 case UO_Minus:
Eli Friedman7df71ac2009-06-14 22:39:26 +0000791 if (isa<UnaryOperator>(Node->getSubExpr()))
792 OS << ' ';
793 break;
Chris Lattner296bf192007-08-23 21:46:40 +0000794 }
795 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000796 PrintExpr(Node->getSubExpr());
Mike Stump1eb44332009-09-09 15:08:12 +0000797
Reid Spencer5f016e22007-07-11 17:01:13 +0000798 if (Node->isPostfix())
799 OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
Reid Spencer5f016e22007-07-11 17:01:13 +0000800}
Chris Lattner704fe352007-08-30 17:59:59 +0000801
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000802void StmtPrinter::VisitOffsetOfExpr(OffsetOfExpr *Node) {
803 OS << "__builtin_offsetof(";
Daniel Dunbar6cb5b5f2010-06-30 19:16:48 +0000804 OS << Node->getTypeSourceInfo()->getType().getAsString(Policy) << ", ";
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000805 bool PrintedSomething = false;
806 for (unsigned i = 0, n = Node->getNumComponents(); i < n; ++i) {
807 OffsetOfExpr::OffsetOfNode ON = Node->getComponent(i);
808 if (ON.getKind() == OffsetOfExpr::OffsetOfNode::Array) {
809 // Array node
810 OS << "[";
811 PrintExpr(Node->getIndexExpr(ON.getArrayExprIndex()));
812 OS << "]";
813 PrintedSomething = true;
814 continue;
815 }
Douglas Gregorcc8a5d52010-04-29 00:18:15 +0000816
817 // Skip implicit base indirections.
818 if (ON.getKind() == OffsetOfExpr::OffsetOfNode::Base)
819 continue;
820
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000821 // Field or identifier node.
822 IdentifierInfo *Id = ON.getFieldName();
823 if (!Id)
824 continue;
Sean Huntc3021132010-05-05 15:23:54 +0000825
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000826 if (PrintedSomething)
827 OS << ".";
828 else
829 PrintedSomething = true;
Sean Huntc3021132010-05-05 15:23:54 +0000830 OS << Id->getName();
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000831 }
832 OS << ")";
833}
834
Peter Collingbournef4e3cfb2011-03-11 19:24:49 +0000835void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node){
836 switch(Node->getKind()) {
837 case UETT_SizeOf:
838 OS << "sizeof";
839 break;
840 case UETT_AlignOf:
Jordan Rosef70a8862012-06-30 21:33:57 +0000841 if (Policy.LangOpts.CPlusPlus)
842 OS << "alignof";
843 else if (Policy.LangOpts.C11)
844 OS << "_Alignof";
845 else
846 OS << "__alignof";
Peter Collingbournef4e3cfb2011-03-11 19:24:49 +0000847 break;
848 case UETT_VecStep:
849 OS << "vec_step";
850 break;
851 }
Sebastian Redl05189992008-11-11 17:56:53 +0000852 if (Node->isArgumentType())
Daniel Dunbar6cb5b5f2010-06-30 19:16:48 +0000853 OS << "(" << Node->getArgumentType().getAsString(Policy) << ")";
Sebastian Redl05189992008-11-11 17:56:53 +0000854 else {
855 OS << " ";
856 PrintExpr(Node->getArgumentExpr());
857 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000858}
Peter Collingbournef111d932011-04-15 00:35:48 +0000859
860void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) {
861 OS << "_Generic(";
862 PrintExpr(Node->getControllingExpr());
863 for (unsigned i = 0; i != Node->getNumAssocs(); ++i) {
864 OS << ", ";
865 QualType T = Node->getAssocType(i);
866 if (T.isNull())
867 OS << "default";
868 else
869 OS << T.getAsString(Policy);
870 OS << ": ";
871 PrintExpr(Node->getAssocExpr(i));
872 }
873 OS << ")";
874}
875
Reid Spencer5f016e22007-07-11 17:01:13 +0000876void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) {
Ted Kremenek23245122007-08-20 16:18:38 +0000877 PrintExpr(Node->getLHS());
Reid Spencer5f016e22007-07-11 17:01:13 +0000878 OS << "[";
Ted Kremenek23245122007-08-20 16:18:38 +0000879 PrintExpr(Node->getRHS());
Reid Spencer5f016e22007-07-11 17:01:13 +0000880 OS << "]";
881}
882
Peter Collingbourned64e2372011-02-08 21:17:54 +0000883void StmtPrinter::PrintCallArgs(CallExpr *Call) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000884 for (unsigned i = 0, e = Call->getNumArgs(); i != e; ++i) {
Chris Lattner04421082008-04-08 04:40:51 +0000885 if (isa<CXXDefaultArgExpr>(Call->getArg(i))) {
886 // Don't print any defaulted arguments
887 break;
888 }
889
Reid Spencer5f016e22007-07-11 17:01:13 +0000890 if (i) OS << ", ";
891 PrintExpr(Call->getArg(i));
892 }
Peter Collingbourned64e2372011-02-08 21:17:54 +0000893}
894
895void StmtPrinter::VisitCallExpr(CallExpr *Call) {
896 PrintExpr(Call->getCallee());
897 OS << "(";
898 PrintCallArgs(Call);
Reid Spencer5f016e22007-07-11 17:01:13 +0000899 OS << ")";
900}
901void StmtPrinter::VisitMemberExpr(MemberExpr *Node) {
Douglas Gregorb3eef682009-01-08 22:45:41 +0000902 // FIXME: Suppress printing implicit bases (like "this")
903 PrintExpr(Node->getBase());
Fariborz Jahanian97fd83a2010-01-11 21:17:32 +0000904 if (FieldDecl *FD = dyn_cast<FieldDecl>(Node->getMemberDecl()))
905 if (FD->isAnonymousStructOrUnion())
906 return;
Douglas Gregorb3eef682009-01-08 22:45:41 +0000907 OS << (Node->isArrow() ? "->" : ".");
Douglas Gregor83f6faf2009-08-31 23:41:50 +0000908 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
909 Qualifier->print(OS, Policy);
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000910 if (Node->hasTemplateKeyword())
911 OS << "template ";
Abramo Bagnara25777432010-08-11 22:01:17 +0000912 OS << Node->getMemberNameInfo();
John McCall096832c2010-08-19 23:49:38 +0000913 if (Node->hasExplicitTemplateArgs())
Douglas Gregorc4bf26f2009-09-01 00:37:14 +0000914 OS << TemplateSpecializationType::PrintTemplateArgumentList(
915 Node->getTemplateArgs(),
916 Node->getNumTemplateArgs(),
917 Policy);
Reid Spencer5f016e22007-07-11 17:01:13 +0000918}
Steve Narofff242b1b2009-07-24 17:54:45 +0000919void StmtPrinter::VisitObjCIsaExpr(ObjCIsaExpr *Node) {
920 PrintExpr(Node->getBase());
921 OS << (Node->isArrow() ? "->isa" : ".isa");
922}
923
Nate Begeman213541a2008-04-18 23:10:10 +0000924void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
Steve Naroff31a45842007-07-28 23:10:27 +0000925 PrintExpr(Node->getBase());
926 OS << ".";
927 OS << Node->getAccessor().getName();
928}
Douglas Gregor6eec8e82008-10-28 15:36:24 +0000929void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) {
Fariborz Jahanian03e80e42010-06-30 16:31:08 +0000930 OS << "(" << Node->getType().getAsString(Policy) << ")";
Reid Spencer5f016e22007-07-11 17:01:13 +0000931 PrintExpr(Node->getSubExpr());
932}
Steve Naroffaff1edd2007-07-19 21:32:11 +0000933void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) {
Daniel Dunbar6cb5b5f2010-06-30 19:16:48 +0000934 OS << "(" << Node->getType().getAsString(Policy) << ")";
Steve Naroffaff1edd2007-07-19 21:32:11 +0000935 PrintExpr(Node->getInitializer());
936}
Steve Naroff49b45262007-07-13 16:58:59 +0000937void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
Steve Naroff90045e82007-07-13 23:32:42 +0000938 // No need to print anything, simply forward to the sub expression.
939 PrintExpr(Node->getSubExpr());
Steve Naroff49b45262007-07-13 16:58:59 +0000940}
Reid Spencer5f016e22007-07-11 17:01:13 +0000941void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) {
942 PrintExpr(Node->getLHS());
943 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
944 PrintExpr(Node->getRHS());
945}
Chris Lattnereb14fe82007-08-25 02:00:02 +0000946void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
947 PrintExpr(Node->getLHS());
948 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
949 PrintExpr(Node->getRHS());
950}
Reid Spencer5f016e22007-07-11 17:01:13 +0000951void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) {
952 PrintExpr(Node->getCond());
John McCall56ca35d2011-02-17 10:25:35 +0000953 OS << " ? ";
954 PrintExpr(Node->getLHS());
955 OS << " : ";
Reid Spencer5f016e22007-07-11 17:01:13 +0000956 PrintExpr(Node->getRHS());
957}
958
959// GNU extensions.
960
John McCall56ca35d2011-02-17 10:25:35 +0000961void
962StmtPrinter::VisitBinaryConditionalOperator(BinaryConditionalOperator *Node) {
963 PrintExpr(Node->getCommon());
964 OS << " ?: ";
965 PrintExpr(Node->getFalseExpr());
966}
Chris Lattner6481a572007-08-03 17:31:20 +0000967void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000968 OS << "&&" << Node->getLabel()->getName();
Reid Spencer5f016e22007-07-11 17:01:13 +0000969}
970
Chris Lattnerab18c4c2007-07-24 16:58:17 +0000971void StmtPrinter::VisitStmtExpr(StmtExpr *E) {
972 OS << "(";
973 PrintRawCompoundStmt(E->getSubStmt());
974 OS << ")";
975}
976
Steve Naroffd04fdd52007-08-03 21:21:27 +0000977void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) {
978 OS << "__builtin_choose_expr(";
979 PrintExpr(Node->getCond());
Chris Lattner94f05e32007-08-04 00:20:15 +0000980 OS << ", ";
Steve Naroffd04fdd52007-08-03 21:21:27 +0000981 PrintExpr(Node->getLHS());
Chris Lattner94f05e32007-08-04 00:20:15 +0000982 OS << ", ";
Steve Naroffd04fdd52007-08-03 21:21:27 +0000983 PrintExpr(Node->getRHS());
984 OS << ")";
985}
Chris Lattnerab18c4c2007-07-24 16:58:17 +0000986
Douglas Gregor2d8b2732008-11-29 04:51:27 +0000987void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {
988 OS << "__null";
989}
990
Eli Friedmand38617c2008-05-14 19:38:39 +0000991void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) {
992 OS << "__builtin_shufflevector(";
993 for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) {
994 if (i) OS << ", ";
995 PrintExpr(Node->getExpr(i));
996 }
997 OS << ")";
998}
999
Anders Carlsson66b5a8a2007-08-31 04:56:16 +00001000void StmtPrinter::VisitInitListExpr(InitListExpr* Node) {
Douglas Gregor64f65002009-05-30 00:56:08 +00001001 if (Node->getSyntacticForm()) {
1002 Visit(Node->getSyntacticForm());
1003 return;
1004 }
1005
Anders Carlsson66b5a8a2007-08-31 04:56:16 +00001006 OS << "{ ";
1007 for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) {
1008 if (i) OS << ", ";
Douglas Gregor4c678342009-01-28 21:54:33 +00001009 if (Node->getInit(i))
1010 PrintExpr(Node->getInit(i));
1011 else
1012 OS << "0";
Anders Carlsson66b5a8a2007-08-31 04:56:16 +00001013 }
1014 OS << " }";
1015}
1016
Nate Begeman2ef13e52009-08-10 23:49:36 +00001017void StmtPrinter::VisitParenListExpr(ParenListExpr* Node) {
1018 OS << "( ";
1019 for (unsigned i = 0, e = Node->getNumExprs(); i != e; ++i) {
1020 if (i) OS << ", ";
1021 PrintExpr(Node->getExpr(i));
1022 }
1023 OS << " )";
1024}
1025
Douglas Gregor05c13a32009-01-22 00:58:24 +00001026void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001027 for (DesignatedInitExpr::designators_iterator D = Node->designators_begin(),
1028 DEnd = Node->designators_end();
1029 D != DEnd; ++D) {
1030 if (D->isFieldDesignator()) {
1031 if (D->getDotLoc().isInvalid())
1032 OS << D->getFieldName()->getName() << ":";
1033 else
1034 OS << "." << D->getFieldName()->getName();
1035 } else {
1036 OS << "[";
1037 if (D->isArrayDesignator()) {
1038 PrintExpr(Node->getArrayIndex(*D));
1039 } else {
1040 PrintExpr(Node->getArrayRangeStart(*D));
1041 OS << " ... ";
Mike Stump1eb44332009-09-09 15:08:12 +00001042 PrintExpr(Node->getArrayRangeEnd(*D));
Douglas Gregor4c678342009-01-28 21:54:33 +00001043 }
1044 OS << "]";
1045 }
1046 }
1047
1048 OS << " = ";
1049 PrintExpr(Node->getInit());
Douglas Gregor05c13a32009-01-22 00:58:24 +00001050}
1051
Douglas Gregor3498bdb2009-01-29 17:44:32 +00001052void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) {
Chris Lattnere4f21422009-06-30 01:26:17 +00001053 if (Policy.LangOpts.CPlusPlus)
Douglas Gregor4fe0c8e2009-05-30 00:08:05 +00001054 OS << "/*implicit*/" << Node->getType().getAsString(Policy) << "()";
1055 else {
1056 OS << "/*implicit*/(" << Node->getType().getAsString(Policy) << ")";
1057 if (Node->getType()->isRecordType())
1058 OS << "{}";
1059 else
1060 OS << 0;
1061 }
Douglas Gregor3498bdb2009-01-29 17:44:32 +00001062}
1063
Anders Carlsson7c50aca2007-10-15 20:28:48 +00001064void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) {
Eli Friedman42f42c02009-05-30 04:20:30 +00001065 OS << "__builtin_va_arg(";
Anders Carlsson7c50aca2007-10-15 20:28:48 +00001066 PrintExpr(Node->getSubExpr());
1067 OS << ", ";
Daniel Dunbar6cb5b5f2010-06-30 19:16:48 +00001068 OS << Node->getType().getAsString(Policy);
Anders Carlsson7c50aca2007-10-15 20:28:48 +00001069 OS << ")";
1070}
1071
John McCall4b9c2d22011-11-06 09:01:30 +00001072void StmtPrinter::VisitPseudoObjectExpr(PseudoObjectExpr *Node) {
1073 PrintExpr(Node->getSyntacticForm());
1074}
1075
Eli Friedman276b0612011-10-11 02:20:01 +00001076void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) {
Eli Friedman9e3c20b2011-10-11 20:00:47 +00001077 const char *Name = 0;
Eli Friedman276b0612011-10-11 02:20:01 +00001078 switch (Node->getOp()) {
Richard Smithff34d402012-04-12 05:08:17 +00001079#define BUILTIN(ID, TYPE, ATTRS)
1080#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
1081 case AtomicExpr::AO ## ID: \
1082 Name = #ID "("; \
1083 break;
1084#include "clang/Basic/Builtins.def"
Eli Friedman276b0612011-10-11 02:20:01 +00001085 }
1086 OS << Name;
Richard Smithff34d402012-04-12 05:08:17 +00001087
1088 // AtomicExpr stores its subexpressions in a permuted order.
Eli Friedman276b0612011-10-11 02:20:01 +00001089 PrintExpr(Node->getPtr());
1090 OS << ", ";
Richard Smithff34d402012-04-12 05:08:17 +00001091 if (Node->getOp() != AtomicExpr::AO__c11_atomic_load &&
1092 Node->getOp() != AtomicExpr::AO__atomic_load_n) {
Eli Friedman276b0612011-10-11 02:20:01 +00001093 PrintExpr(Node->getVal1());
1094 OS << ", ";
1095 }
Richard Smithff34d402012-04-12 05:08:17 +00001096 if (Node->getOp() == AtomicExpr::AO__atomic_exchange ||
1097 Node->isCmpXChg()) {
Eli Friedman276b0612011-10-11 02:20:01 +00001098 PrintExpr(Node->getVal2());
1099 OS << ", ";
1100 }
Richard Smithff34d402012-04-12 05:08:17 +00001101 if (Node->getOp() == AtomicExpr::AO__atomic_compare_exchange ||
1102 Node->getOp() == AtomicExpr::AO__atomic_compare_exchange_n) {
1103 PrintExpr(Node->getWeak());
1104 OS << ", ";
1105 }
1106 if (Node->getOp() != AtomicExpr::AO__c11_atomic_init)
David Chisnall7a7ee302012-01-16 17:27:18 +00001107 PrintExpr(Node->getOrder());
Eli Friedman276b0612011-10-11 02:20:01 +00001108 if (Node->isCmpXChg()) {
1109 OS << ", ";
1110 PrintExpr(Node->getOrderFail());
1111 }
1112 OS << ")";
1113}
1114
Reid Spencer5f016e22007-07-11 17:01:13 +00001115// C++
Douglas Gregorb4609802008-11-14 16:09:21 +00001116void StmtPrinter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *Node) {
1117 const char *OpStrings[NUM_OVERLOADED_OPERATORS] = {
1118 "",
1119#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
1120 Spelling,
1121#include "clang/Basic/OperatorKinds.def"
1122 };
1123
1124 OverloadedOperatorKind Kind = Node->getOperator();
1125 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
1126 if (Node->getNumArgs() == 1) {
1127 OS << OpStrings[Kind] << ' ';
1128 PrintExpr(Node->getArg(0));
1129 } else {
1130 PrintExpr(Node->getArg(0));
1131 OS << ' ' << OpStrings[Kind];
1132 }
Eli Friedmana143a9d2012-10-12 22:45:14 +00001133 } else if (Kind == OO_Arrow) {
1134 PrintExpr(Node->getArg(0));
Douglas Gregorb4609802008-11-14 16:09:21 +00001135 } else if (Kind == OO_Call) {
1136 PrintExpr(Node->getArg(0));
1137 OS << '(';
1138 for (unsigned ArgIdx = 1; ArgIdx < Node->getNumArgs(); ++ArgIdx) {
1139 if (ArgIdx > 1)
1140 OS << ", ";
1141 if (!isa<CXXDefaultArgExpr>(Node->getArg(ArgIdx)))
1142 PrintExpr(Node->getArg(ArgIdx));
1143 }
1144 OS << ')';
1145 } else if (Kind == OO_Subscript) {
1146 PrintExpr(Node->getArg(0));
1147 OS << '[';
1148 PrintExpr(Node->getArg(1));
1149 OS << ']';
1150 } else if (Node->getNumArgs() == 1) {
1151 OS << OpStrings[Kind] << ' ';
1152 PrintExpr(Node->getArg(0));
1153 } else if (Node->getNumArgs() == 2) {
1154 PrintExpr(Node->getArg(0));
1155 OS << ' ' << OpStrings[Kind] << ' ';
1156 PrintExpr(Node->getArg(1));
1157 } else {
David Blaikieb219cfc2011-09-23 05:06:16 +00001158 llvm_unreachable("unknown overloaded operator");
Douglas Gregorb4609802008-11-14 16:09:21 +00001159 }
1160}
Reid Spencer5f016e22007-07-11 17:01:13 +00001161
Douglas Gregor88a35142008-12-22 05:46:06 +00001162void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) {
1163 VisitCallExpr(cast<CallExpr>(Node));
1164}
1165
Peter Collingbournee08ce652011-02-09 21:07:24 +00001166void StmtPrinter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *Node) {
1167 PrintExpr(Node->getCallee());
1168 OS << "<<<";
1169 PrintCallArgs(Node->getConfig());
1170 OS << ">>>(";
1171 PrintCallArgs(Node);
1172 OS << ")";
1173}
1174
Douglas Gregor49badde2008-10-27 19:41:14 +00001175void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
1176 OS << Node->getCastName() << '<';
Daniel Dunbar6cb5b5f2010-06-30 19:16:48 +00001177 OS << Node->getTypeAsWritten().getAsString(Policy) << ">(";
Reid Spencer5f016e22007-07-11 17:01:13 +00001178 PrintExpr(Node->getSubExpr());
1179 OS << ")";
1180}
1181
Douglas Gregor49badde2008-10-27 19:41:14 +00001182void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) {
1183 VisitCXXNamedCastExpr(Node);
1184}
1185
1186void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) {
1187 VisitCXXNamedCastExpr(Node);
1188}
1189
1190void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
1191 VisitCXXNamedCastExpr(Node);
1192}
1193
1194void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
1195 VisitCXXNamedCastExpr(Node);
1196}
1197
Sebastian Redlc42e1182008-11-11 11:37:55 +00001198void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) {
1199 OS << "typeid(";
1200 if (Node->isTypeOperand()) {
Daniel Dunbar6cb5b5f2010-06-30 19:16:48 +00001201 OS << Node->getTypeOperand().getAsString(Policy);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001202 } else {
1203 PrintExpr(Node->getExprOperand());
1204 }
1205 OS << ")";
1206}
1207
Francois Pichet01b7c302010-09-08 12:20:18 +00001208void StmtPrinter::VisitCXXUuidofExpr(CXXUuidofExpr *Node) {
1209 OS << "__uuidof(";
1210 if (Node->isTypeOperand()) {
1211 OS << Node->getTypeOperand().getAsString(Policy);
1212 } else {
1213 PrintExpr(Node->getExprOperand());
1214 }
1215 OS << ")";
1216}
1217
Richard Smith9fcce652012-03-07 08:35:16 +00001218void StmtPrinter::VisitUserDefinedLiteral(UserDefinedLiteral *Node) {
1219 switch (Node->getLiteralOperatorKind()) {
1220 case UserDefinedLiteral::LOK_Raw:
Richard Smithef9f2982012-03-09 10:10:02 +00001221 OS << cast<StringLiteral>(Node->getArg(0)->IgnoreImpCasts())->getString();
Richard Smith9fcce652012-03-07 08:35:16 +00001222 break;
1223 case UserDefinedLiteral::LOK_Template: {
Richard Smithef9f2982012-03-09 10:10:02 +00001224 DeclRefExpr *DRE = cast<DeclRefExpr>(Node->getCallee()->IgnoreImpCasts());
1225 const TemplateArgumentList *Args =
1226 cast<FunctionDecl>(DRE->getDecl())->getTemplateSpecializationArgs();
1227 assert(Args);
1228 const TemplateArgument &Pack = Args->get(0);
1229 for (TemplateArgument::pack_iterator I = Pack.pack_begin(),
1230 E = Pack.pack_end(); I != E; ++I) {
Benjamin Kramer85524372012-06-07 15:09:51 +00001231 char C = (char)I->getAsIntegral().getZExtValue();
Richard Smith9fcce652012-03-07 08:35:16 +00001232 OS << C;
1233 }
1234 break;
1235 }
Richard Smith91688302012-03-08 09:02:38 +00001236 case UserDefinedLiteral::LOK_Integer: {
1237 // Print integer literal without suffix.
1238 IntegerLiteral *Int = cast<IntegerLiteral>(Node->getCookedLiteral());
1239 OS << Int->getValue().toString(10, /*isSigned*/false);
1240 break;
1241 }
Benjamin Kramera0a3c902012-09-20 14:07:17 +00001242 case UserDefinedLiteral::LOK_Floating: {
1243 // Print floating literal without suffix.
1244 FloatingLiteral *Float = cast<FloatingLiteral>(Node->getCookedLiteral());
1245 PrintFloatingLiteral(OS, Float, /*PrintSuffix=*/false);
1246 break;
1247 }
Richard Smith9fcce652012-03-07 08:35:16 +00001248 case UserDefinedLiteral::LOK_String:
1249 case UserDefinedLiteral::LOK_Character:
1250 PrintExpr(Node->getCookedLiteral());
1251 break;
1252 }
1253 OS << Node->getUDSuffix()->getName();
1254}
1255
Reid Spencer5f016e22007-07-11 17:01:13 +00001256void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
1257 OS << (Node->getValue() ? "true" : "false");
1258}
1259
Sebastian Redl6e8ed162009-05-10 18:38:11 +00001260void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) {
1261 OS << "nullptr";
1262}
1263
Douglas Gregor796da182008-11-04 14:32:21 +00001264void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) {
1265 OS << "this";
1266}
1267
Chris Lattner50dd2892008-02-26 00:51:44 +00001268void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) {
1269 if (Node->getSubExpr() == 0)
1270 OS << "throw";
1271 else {
1272 OS << "throw ";
1273 PrintExpr(Node->getSubExpr());
1274 }
1275}
1276
Chris Lattner04421082008-04-08 04:40:51 +00001277void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
1278 // Nothing to print: we picked up the default argument
1279}
1280
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001281void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
Daniel Dunbar6cb5b5f2010-06-30 19:16:48 +00001282 OS << Node->getType().getAsString(Policy);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001283 OS << "(";
1284 PrintExpr(Node->getSubExpr());
1285 OS << ")";
1286}
1287
Anders Carlssonfceb0a82009-05-30 20:03:25 +00001288void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
1289 PrintExpr(Node->getSubExpr());
1290}
1291
Douglas Gregor506ae412009-01-16 18:33:17 +00001292void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) {
Daniel Dunbar6cb5b5f2010-06-30 19:16:48 +00001293 OS << Node->getType().getAsString(Policy);
Douglas Gregor506ae412009-01-16 18:33:17 +00001294 OS << "(";
1295 for (CXXTemporaryObjectExpr::arg_iterator Arg = Node->arg_begin(),
Mike Stump1eb44332009-09-09 15:08:12 +00001296 ArgEnd = Node->arg_end();
Douglas Gregor506ae412009-01-16 18:33:17 +00001297 Arg != ArgEnd; ++Arg) {
1298 if (Arg != Node->arg_begin())
1299 OS << ", ";
1300 PrintExpr(*Arg);
1301 }
1302 OS << ")";
1303}
1304
Douglas Gregor01d08012012-02-07 10:09:13 +00001305void StmtPrinter::VisitLambdaExpr(LambdaExpr *Node) {
1306 OS << '[';
1307 bool NeedComma = false;
1308 switch (Node->getCaptureDefault()) {
1309 case LCD_None:
1310 break;
1311
1312 case LCD_ByCopy:
1313 OS << '=';
1314 NeedComma = true;
1315 break;
1316
1317 case LCD_ByRef:
1318 OS << '&';
1319 NeedComma = true;
1320 break;
1321 }
1322 for (LambdaExpr::capture_iterator C = Node->explicit_capture_begin(),
1323 CEnd = Node->explicit_capture_end();
1324 C != CEnd;
1325 ++C) {
1326 if (NeedComma)
1327 OS << ", ";
1328 NeedComma = true;
1329
1330 switch (C->getCaptureKind()) {
1331 case LCK_This:
1332 OS << "this";
1333 break;
1334
1335 case LCK_ByRef:
1336 if (Node->getCaptureDefault() != LCD_ByRef)
1337 OS << '&';
1338 OS << C->getCapturedVar()->getName();
1339 break;
1340
1341 case LCK_ByCopy:
1342 if (Node->getCaptureDefault() != LCD_ByCopy)
1343 OS << '=';
1344 OS << C->getCapturedVar()->getName();
1345 break;
1346 }
1347 }
1348 OS << ']';
1349
1350 if (Node->hasExplicitParameters()) {
1351 OS << " (";
1352 CXXMethodDecl *Method = Node->getCallOperator();
1353 NeedComma = false;
1354 for (CXXMethodDecl::param_iterator P = Method->param_begin(),
1355 PEnd = Method->param_end();
1356 P != PEnd; ++P) {
1357 if (NeedComma) {
1358 OS << ", ";
1359 } else {
1360 NeedComma = true;
1361 }
1362 std::string ParamStr = (*P)->getNameAsString();
1363 (*P)->getOriginalType().getAsStringInternal(ParamStr, Policy);
1364 OS << ParamStr;
1365 }
1366 if (Method->isVariadic()) {
1367 if (NeedComma)
1368 OS << ", ";
1369 OS << "...";
1370 }
1371 OS << ')';
1372
1373 if (Node->isMutable())
1374 OS << " mutable";
1375
1376 const FunctionProtoType *Proto
1377 = Method->getType()->getAs<FunctionProtoType>();
1378 {
1379 std::string ExceptionSpec;
1380 Proto->printExceptionSpecification(ExceptionSpec, Policy);
1381 OS << ExceptionSpec;
1382 }
1383
1384 // FIXME: Attributes
1385
Douglas Gregordfca6f52012-02-13 22:00:16 +00001386 // Print the trailing return type if it was specified in the source.
1387 if (Node->hasExplicitResultType())
1388 OS << " -> " << Proto->getResultType().getAsString(Policy);
Douglas Gregor01d08012012-02-07 10:09:13 +00001389 }
1390
1391 // Print the body.
1392 CompoundStmt *Body = Node->getBody();
1393 OS << ' ';
1394 PrintStmt(Body);
1395}
1396
Douglas Gregored8abf12010-07-08 06:14:04 +00001397void StmtPrinter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *Node) {
Douglas Gregorab6677e2010-09-08 00:15:04 +00001398 if (TypeSourceInfo *TSInfo = Node->getTypeSourceInfo())
1399 OS << TSInfo->getType().getAsString(Policy) << "()";
1400 else
1401 OS << Node->getType().getAsString(Policy) << "()";
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001402}
1403
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001404void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) {
1405 if (E->isGlobalNew())
1406 OS << "::";
1407 OS << "new ";
1408 unsigned NumPlace = E->getNumPlacementArgs();
1409 if (NumPlace > 0) {
1410 OS << "(";
1411 PrintExpr(E->getPlacementArg(0));
1412 for (unsigned i = 1; i < NumPlace; ++i) {
1413 OS << ", ";
1414 PrintExpr(E->getPlacementArg(i));
1415 }
1416 OS << ") ";
1417 }
1418 if (E->isParenTypeId())
1419 OS << "(";
Sebastian Redl6fec6482008-12-02 22:08:59 +00001420 std::string TypeS;
1421 if (Expr *Size = E->getArraySize()) {
1422 llvm::raw_string_ostream s(TypeS);
Richard Smithd1420c62012-08-16 03:56:14 +00001423 Size->printPretty(s, Helper, Policy);
Sebastian Redl6fec6482008-12-02 22:08:59 +00001424 s.flush();
1425 TypeS = "[" + TypeS + "]";
1426 }
Douglas Gregord249e1d1f2009-05-29 20:38:28 +00001427 E->getAllocatedType().getAsStringInternal(TypeS, Policy);
Sebastian Redl6fec6482008-12-02 22:08:59 +00001428 OS << TypeS;
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001429 if (E->isParenTypeId())
1430 OS << ")";
1431
Sebastian Redl2aed8b82012-02-16 12:22:20 +00001432 CXXNewExpr::InitializationStyle InitStyle = E->getInitializationStyle();
1433 if (InitStyle) {
1434 if (InitStyle == CXXNewExpr::CallInit)
1435 OS << "(";
1436 PrintExpr(E->getInitializer());
1437 if (InitStyle == CXXNewExpr::CallInit)
1438 OS << ")";
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001439 }
1440}
1441
1442void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1443 if (E->isGlobalDelete())
1444 OS << "::";
1445 OS << "delete ";
1446 if (E->isArrayForm())
1447 OS << "[] ";
1448 PrintExpr(E->getArgument());
1449}
1450
Douglas Gregora71d8192009-09-04 17:36:40 +00001451void StmtPrinter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1452 PrintExpr(E->getBase());
1453 if (E->isArrow())
1454 OS << "->";
1455 else
1456 OS << '.';
1457 if (E->getQualifier())
1458 E->getQualifier()->print(OS, Policy);
Mike Stump1eb44332009-09-09 15:08:12 +00001459
Douglas Gregora71d8192009-09-04 17:36:40 +00001460 std::string TypeS;
Douglas Gregora2e7dd22010-02-25 01:56:36 +00001461 if (IdentifierInfo *II = E->getDestroyedTypeIdentifier())
1462 OS << II->getName();
1463 else
1464 E->getDestroyedType().getAsStringInternal(TypeS, Policy);
Douglas Gregora71d8192009-09-04 17:36:40 +00001465 OS << TypeS;
1466}
1467
Anders Carlssone349bea2009-04-23 02:32:43 +00001468void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) {
Douglas Gregord0fb3ad2011-01-24 17:25:03 +00001469 for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
1470 if (isa<CXXDefaultArgExpr>(E->getArg(i))) {
1471 // Don't print any defaulted arguments
1472 break;
1473 }
1474
1475 if (i) OS << ", ";
1476 PrintExpr(E->getArg(i));
Fariborz Jahanianc75da512010-01-13 21:41:11 +00001477 }
Anders Carlssone349bea2009-04-23 02:32:43 +00001478}
1479
John McCall4765fa02010-12-06 08:20:24 +00001480void StmtPrinter::VisitExprWithCleanups(ExprWithCleanups *E) {
Anders Carlsson02bbfa32009-04-24 22:47:04 +00001481 // Just forward to the sub expression.
1482 PrintExpr(E->getSubExpr());
1483}
1484
Mike Stump1eb44332009-09-09 15:08:12 +00001485void
Douglas Gregord81e6ca2009-05-20 18:46:25 +00001486StmtPrinter::VisitCXXUnresolvedConstructExpr(
1487 CXXUnresolvedConstructExpr *Node) {
Daniel Dunbar6cb5b5f2010-06-30 19:16:48 +00001488 OS << Node->getTypeAsWritten().getAsString(Policy);
Douglas Gregord81e6ca2009-05-20 18:46:25 +00001489 OS << "(";
1490 for (CXXUnresolvedConstructExpr::arg_iterator Arg = Node->arg_begin(),
Mike Stump1eb44332009-09-09 15:08:12 +00001491 ArgEnd = Node->arg_end();
Douglas Gregord81e6ca2009-05-20 18:46:25 +00001492 Arg != ArgEnd; ++Arg) {
1493 if (Arg != Node->arg_begin())
1494 OS << ", ";
1495 PrintExpr(*Arg);
1496 }
1497 OS << ")";
1498}
1499
John McCall865d4472009-11-19 22:55:06 +00001500void StmtPrinter::VisitCXXDependentScopeMemberExpr(
1501 CXXDependentScopeMemberExpr *Node) {
John McCallaa81e162009-12-01 22:10:20 +00001502 if (!Node->isImplicitAccess()) {
1503 PrintExpr(Node->getBase());
1504 OS << (Node->isArrow() ? "->" : ".");
1505 }
Douglas Gregora38c6872009-09-03 16:14:30 +00001506 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
1507 Qualifier->print(OS, Policy);
Abramo Bagnarae4b92762012-01-27 09:46:47 +00001508 if (Node->hasTemplateKeyword())
Douglas Gregor3b6afbb2009-09-09 00:23:06 +00001509 OS << "template ";
Abramo Bagnara25777432010-08-11 22:01:17 +00001510 OS << Node->getMemberNameInfo();
John McCallaa81e162009-12-01 22:10:20 +00001511 if (Node->hasExplicitTemplateArgs()) {
Douglas Gregor3b6afbb2009-09-09 00:23:06 +00001512 OS << TemplateSpecializationType::PrintTemplateArgumentList(
1513 Node->getTemplateArgs(),
1514 Node->getNumTemplateArgs(),
1515 Policy);
1516 }
Douglas Gregor1c0ca592009-05-22 21:13:27 +00001517}
1518
John McCall129e2df2009-11-30 22:42:35 +00001519void StmtPrinter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *Node) {
John McCallaa81e162009-12-01 22:10:20 +00001520 if (!Node->isImplicitAccess()) {
1521 PrintExpr(Node->getBase());
1522 OS << (Node->isArrow() ? "->" : ".");
1523 }
John McCall129e2df2009-11-30 22:42:35 +00001524 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
1525 Qualifier->print(OS, Policy);
Abramo Bagnarae4b92762012-01-27 09:46:47 +00001526 if (Node->hasTemplateKeyword())
1527 OS << "template ";
Abramo Bagnara25777432010-08-11 22:01:17 +00001528 OS << Node->getMemberNameInfo();
John McCall129e2df2009-11-30 22:42:35 +00001529 if (Node->hasExplicitTemplateArgs()) {
1530 OS << TemplateSpecializationType::PrintTemplateArgumentList(
1531 Node->getTemplateArgs(),
1532 Node->getNumTemplateArgs(),
1533 Policy);
1534 }
1535}
1536
Sebastian Redl64b45f72009-01-05 20:52:13 +00001537static const char *getTypeTraitName(UnaryTypeTrait UTT) {
1538 switch (UTT) {
Sebastian Redl64b45f72009-01-05 20:52:13 +00001539 case UTT_HasNothrowAssign: return "__has_nothrow_assign";
Sebastian Redl64b45f72009-01-05 20:52:13 +00001540 case UTT_HasNothrowConstructor: return "__has_nothrow_constructor";
John Wiegley20c0da72011-04-27 23:09:49 +00001541 case UTT_HasNothrowCopy: return "__has_nothrow_copy";
Sebastian Redl64b45f72009-01-05 20:52:13 +00001542 case UTT_HasTrivialAssign: return "__has_trivial_assign";
Sean Hunt023df372011-05-09 18:22:59 +00001543 case UTT_HasTrivialDefaultConstructor: return "__has_trivial_constructor";
John Wiegley20c0da72011-04-27 23:09:49 +00001544 case UTT_HasTrivialCopy: return "__has_trivial_copy";
Sebastian Redl64b45f72009-01-05 20:52:13 +00001545 case UTT_HasTrivialDestructor: return "__has_trivial_destructor";
1546 case UTT_HasVirtualDestructor: return "__has_virtual_destructor";
1547 case UTT_IsAbstract: return "__is_abstract";
John Wiegley20c0da72011-04-27 23:09:49 +00001548 case UTT_IsArithmetic: return "__is_arithmetic";
1549 case UTT_IsArray: return "__is_array";
Sebastian Redl64b45f72009-01-05 20:52:13 +00001550 case UTT_IsClass: return "__is_class";
John Wiegley20c0da72011-04-27 23:09:49 +00001551 case UTT_IsCompleteType: return "__is_complete_type";
1552 case UTT_IsCompound: return "__is_compound";
1553 case UTT_IsConst: return "__is_const";
Sebastian Redl64b45f72009-01-05 20:52:13 +00001554 case UTT_IsEmpty: return "__is_empty";
1555 case UTT_IsEnum: return "__is_enum";
Douglas Gregor5e9392b2011-12-03 18:14:24 +00001556 case UTT_IsFinal: return "__is_final";
John Wiegley20c0da72011-04-27 23:09:49 +00001557 case UTT_IsFloatingPoint: return "__is_floating_point";
1558 case UTT_IsFunction: return "__is_function";
1559 case UTT_IsFundamental: return "__is_fundamental";
1560 case UTT_IsIntegral: return "__is_integral";
John McCallea30e2f2012-09-25 07:32:49 +00001561 case UTT_IsInterfaceClass: return "__is_interface_class";
Chandler Carruthe1947102011-05-01 07:23:20 +00001562 case UTT_IsLiteral: return "__is_literal";
John Wiegley20c0da72011-04-27 23:09:49 +00001563 case UTT_IsLvalueReference: return "__is_lvalue_reference";
1564 case UTT_IsMemberFunctionPointer: return "__is_member_function_pointer";
1565 case UTT_IsMemberObjectPointer: return "__is_member_object_pointer";
1566 case UTT_IsMemberPointer: return "__is_member_pointer";
1567 case UTT_IsObject: return "__is_object";
Sebastian Redl64b45f72009-01-05 20:52:13 +00001568 case UTT_IsPOD: return "__is_pod";
John Wiegley20c0da72011-04-27 23:09:49 +00001569 case UTT_IsPointer: return "__is_pointer";
Sebastian Redl64b45f72009-01-05 20:52:13 +00001570 case UTT_IsPolymorphic: return "__is_polymorphic";
John Wiegley20c0da72011-04-27 23:09:49 +00001571 case UTT_IsReference: return "__is_reference";
John Wiegley20c0da72011-04-27 23:09:49 +00001572 case UTT_IsRvalueReference: return "__is_rvalue_reference";
1573 case UTT_IsScalar: return "__is_scalar";
1574 case UTT_IsSigned: return "__is_signed";
1575 case UTT_IsStandardLayout: return "__is_standard_layout";
1576 case UTT_IsTrivial: return "__is_trivial";
Sean Huntfeb375d2011-05-13 00:31:07 +00001577 case UTT_IsTriviallyCopyable: return "__is_trivially_copyable";
Sebastian Redl64b45f72009-01-05 20:52:13 +00001578 case UTT_IsUnion: return "__is_union";
John Wiegley20c0da72011-04-27 23:09:49 +00001579 case UTT_IsUnsigned: return "__is_unsigned";
1580 case UTT_IsVoid: return "__is_void";
1581 case UTT_IsVolatile: return "__is_volatile";
Sebastian Redl64b45f72009-01-05 20:52:13 +00001582 }
Chandler Carruthe1947102011-05-01 07:23:20 +00001583 llvm_unreachable("Type trait not covered by switch statement");
Francois Pichet6ad6f282010-12-07 00:08:36 +00001584}
1585
1586static const char *getTypeTraitName(BinaryTypeTrait BTT) {
1587 switch (BTT) {
Douglas Gregor25d0a0f2012-02-23 07:33:15 +00001588 case BTT_IsBaseOf: return "__is_base_of";
1589 case BTT_IsConvertible: return "__is_convertible";
1590 case BTT_IsSame: return "__is_same";
1591 case BTT_TypeCompatible: return "__builtin_types_compatible_p";
1592 case BTT_IsConvertibleTo: return "__is_convertible_to";
1593 case BTT_IsTriviallyAssignable: return "__is_trivially_assignable";
Francois Pichet6ad6f282010-12-07 00:08:36 +00001594 }
Chandler Carrutha280bc82011-05-01 07:23:23 +00001595 llvm_unreachable("Binary type trait not covered by switch");
Sebastian Redl64b45f72009-01-05 20:52:13 +00001596}
1597
Douglas Gregor4ca8ac22012-02-24 07:38:34 +00001598static const char *getTypeTraitName(TypeTrait TT) {
1599 switch (TT) {
1600 case clang::TT_IsTriviallyConstructible:return "__is_trivially_constructible";
1601 }
1602 llvm_unreachable("Type trait not covered by switch");
1603}
1604
John Wiegley21ff2e52011-04-28 00:16:57 +00001605static const char *getTypeTraitName(ArrayTypeTrait ATT) {
1606 switch (ATT) {
1607 case ATT_ArrayRank: return "__array_rank";
1608 case ATT_ArrayExtent: return "__array_extent";
1609 }
Chandler Carrutha280bc82011-05-01 07:23:23 +00001610 llvm_unreachable("Array type trait not covered by switch");
John Wiegley21ff2e52011-04-28 00:16:57 +00001611}
1612
John Wiegley55262202011-04-25 06:54:41 +00001613static const char *getExpressionTraitName(ExpressionTrait ET) {
1614 switch (ET) {
John Wiegley55262202011-04-25 06:54:41 +00001615 case ET_IsLValueExpr: return "__is_lvalue_expr";
1616 case ET_IsRValueExpr: return "__is_rvalue_expr";
1617 }
Chandler Carrutha280bc82011-05-01 07:23:23 +00001618 llvm_unreachable("Expression type trait not covered by switch");
John Wiegley55262202011-04-25 06:54:41 +00001619}
1620
Sebastian Redl64b45f72009-01-05 20:52:13 +00001621void StmtPrinter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1622 OS << getTypeTraitName(E->getTrait()) << "("
Daniel Dunbar6cb5b5f2010-06-30 19:16:48 +00001623 << E->getQueriedType().getAsString(Policy) << ")";
Sebastian Redl64b45f72009-01-05 20:52:13 +00001624}
1625
Francois Pichet6ad6f282010-12-07 00:08:36 +00001626void StmtPrinter::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1627 OS << getTypeTraitName(E->getTrait()) << "("
1628 << E->getLhsType().getAsString(Policy) << ","
1629 << E->getRhsType().getAsString(Policy) << ")";
1630}
1631
Douglas Gregor4ca8ac22012-02-24 07:38:34 +00001632void StmtPrinter::VisitTypeTraitExpr(TypeTraitExpr *E) {
1633 OS << getTypeTraitName(E->getTrait()) << "(";
1634 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
1635 if (I > 0)
1636 OS << ", ";
1637 OS << E->getArg(I)->getType().getAsString(Policy);
1638 }
1639 OS << ")";
1640}
1641
John Wiegley21ff2e52011-04-28 00:16:57 +00001642void StmtPrinter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1643 OS << getTypeTraitName(E->getTrait()) << "("
1644 << E->getQueriedType().getAsString(Policy) << ")";
1645}
1646
John Wiegley55262202011-04-25 06:54:41 +00001647void StmtPrinter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1648 OS << getExpressionTraitName(E->getTrait()) << "(";
1649 PrintExpr(E->getQueriedExpression());
1650 OS << ")";
1651}
1652
Sebastian Redl2e156222010-09-10 20:55:43 +00001653void StmtPrinter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1654 OS << "noexcept(";
1655 PrintExpr(E->getOperand());
1656 OS << ")";
1657}
1658
Douglas Gregoree8aff02011-01-04 17:33:58 +00001659void StmtPrinter::VisitPackExpansionExpr(PackExpansionExpr *E) {
Douglas Gregorbe230c32011-01-03 17:17:50 +00001660 PrintExpr(E->getPattern());
1661 OS << "...";
1662}
1663
Douglas Gregoree8aff02011-01-04 17:33:58 +00001664void StmtPrinter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
Benjamin Kramera59d20b2012-02-07 11:57:57 +00001665 OS << "sizeof...(" << *E->getPack() << ")";
Douglas Gregoree8aff02011-01-04 17:33:58 +00001666}
1667
Douglas Gregorc7793c72011-01-15 01:15:58 +00001668void StmtPrinter::VisitSubstNonTypeTemplateParmPackExpr(
1669 SubstNonTypeTemplateParmPackExpr *Node) {
Benjamin Kramera59d20b2012-02-07 11:57:57 +00001670 OS << *Node->getParameterPack();
Douglas Gregorc7793c72011-01-15 01:15:58 +00001671}
1672
John McCall91a57552011-07-15 05:09:51 +00001673void StmtPrinter::VisitSubstNonTypeTemplateParmExpr(
1674 SubstNonTypeTemplateParmExpr *Node) {
1675 Visit(Node->getReplacement());
1676}
1677
Richard Smith9a4db032012-09-12 00:56:43 +00001678void StmtPrinter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1679 OS << *E->getParameterPack();
1680}
1681
Douglas Gregor03e80032011-06-21 17:03:29 +00001682void StmtPrinter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *Node){
1683 PrintExpr(Node->GetTemporaryExpr());
1684}
1685
Mike Stump1eb44332009-09-09 15:08:12 +00001686// Obj-C
Anders Carlsson55085182007-08-21 17:43:55 +00001687
1688void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) {
1689 OS << "@";
1690 VisitStringLiteral(Node->getString());
1691}
Reid Spencer5f016e22007-07-11 17:01:13 +00001692
Patrick Beardeb382ec2012-04-19 00:25:12 +00001693void StmtPrinter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
Ted Kremenekebcb57a2012-03-06 20:05:56 +00001694 OS << "@";
Patrick Beardeb382ec2012-04-19 00:25:12 +00001695 Visit(E->getSubExpr());
Ted Kremenekebcb57a2012-03-06 20:05:56 +00001696}
1697
1698void StmtPrinter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1699 OS << "@[ ";
1700 StmtRange ch = E->children();
1701 if (ch.first != ch.second) {
1702 while (1) {
1703 Visit(*ch.first);
1704 ++ch.first;
1705 if (ch.first == ch.second) break;
1706 OS << ", ";
1707 }
1708 }
1709 OS << " ]";
1710}
1711
1712void StmtPrinter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1713 OS << "@{ ";
1714 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
1715 if (I > 0)
1716 OS << ", ";
1717
1718 ObjCDictionaryElement Element = E->getKeyValueElement(I);
1719 Visit(Element.Key);
1720 OS << " : ";
1721 Visit(Element.Value);
1722 if (Element.isPackExpansion())
1723 OS << "...";
1724 }
1725 OS << " }";
1726}
1727
Anders Carlssonf9bcf012007-08-22 15:14:15 +00001728void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
Daniel Dunbar6cb5b5f2010-06-30 19:16:48 +00001729 OS << "@encode(" << Node->getEncodedType().getAsString(Policy) << ')';
Anders Carlssonf9bcf012007-08-22 15:14:15 +00001730}
1731
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00001732void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
Chris Lattner39f34e92008-11-24 04:00:27 +00001733 OS << "@selector(" << Node->getSelector().getAsString() << ')';
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00001734}
1735
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00001736void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
Benjamin Kramerb8989f22011-10-14 18:45:37 +00001737 OS << "@protocol(" << *Node->getProtocol() << ')';
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00001738}
1739
Steve Naroff563477d2007-09-18 23:55:05 +00001740void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) {
1741 OS << "[";
Douglas Gregor04badcf2010-04-21 00:45:42 +00001742 switch (Mess->getReceiverKind()) {
1743 case ObjCMessageExpr::Instance:
1744 PrintExpr(Mess->getInstanceReceiver());
1745 break;
1746
1747 case ObjCMessageExpr::Class:
1748 OS << Mess->getClassReceiver().getAsString(Policy);
1749 break;
1750
1751 case ObjCMessageExpr::SuperInstance:
1752 case ObjCMessageExpr::SuperClass:
1753 OS << "Super";
1754 break;
1755 }
1756
Ted Kremenekc29efd82008-05-02 17:32:38 +00001757 OS << ' ';
Ted Kremenek97b7f262008-04-16 04:30:16 +00001758 Selector selector = Mess->getSelector();
Steve Naroff6a8a9a42007-10-02 20:01:56 +00001759 if (selector.isUnarySelector()) {
Douglas Gregor813d8342011-02-18 22:29:55 +00001760 OS << selector.getNameForSlot(0);
Steve Naroff6a8a9a42007-10-02 20:01:56 +00001761 } else {
1762 for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) {
Ted Kremenekc29efd82008-05-02 17:32:38 +00001763 if (i < selector.getNumArgs()) {
1764 if (i > 0) OS << ' ';
1765 if (selector.getIdentifierInfoForSlot(i))
Chris Lattner39f34e92008-11-24 04:00:27 +00001766 OS << selector.getIdentifierInfoForSlot(i)->getName() << ':';
Ted Kremenekc29efd82008-05-02 17:32:38 +00001767 else
1768 OS << ":";
1769 }
1770 else OS << ", "; // Handle variadic methods.
Mike Stump1eb44332009-09-09 15:08:12 +00001771
Steve Naroff6a8a9a42007-10-02 20:01:56 +00001772 PrintExpr(Mess->getArg(i));
1773 }
Steve Naroff563477d2007-09-18 23:55:05 +00001774 }
1775 OS << "]";
1776}
1777
Ted Kremenekebcb57a2012-03-06 20:05:56 +00001778void StmtPrinter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Node) {
1779 OS << (Node->getValue() ? "__objc_yes" : "__objc_no");
1780}
1781
John McCallf85e1932011-06-15 23:02:42 +00001782void
1783StmtPrinter::VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
1784 PrintExpr(E->getSubExpr());
1785}
1786
1787void
1788StmtPrinter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
1789 OS << "(" << E->getBridgeKindName() << E->getType().getAsString(Policy)
1790 << ")";
1791 PrintExpr(E->getSubExpr());
1792}
Douglas Gregorcd9b46e2008-11-04 14:56:14 +00001793
Steve Naroff4eb206b2008-09-03 18:15:37 +00001794void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
Steve Naroff56ee6892008-10-08 17:01:13 +00001795 BlockDecl *BD = Node->getBlockDecl();
Steve Naroff4eb206b2008-09-03 18:15:37 +00001796 OS << "^";
Mike Stump1eb44332009-09-09 15:08:12 +00001797
Steve Naroff4eb206b2008-09-03 18:15:37 +00001798 const FunctionType *AFT = Node->getFunctionType();
Mike Stump1eb44332009-09-09 15:08:12 +00001799
Douglas Gregor72564e72009-02-26 23:50:07 +00001800 if (isa<FunctionNoProtoType>(AFT)) {
Steve Naroff4eb206b2008-09-03 18:15:37 +00001801 OS << "()";
Douglas Gregor72564e72009-02-26 23:50:07 +00001802 } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) {
Steve Naroff4eb206b2008-09-03 18:15:37 +00001803 OS << '(';
1804 std::string ParamStr;
Steve Naroff56ee6892008-10-08 17:01:13 +00001805 for (BlockDecl::param_iterator AI = BD->param_begin(),
1806 E = BD->param_end(); AI != E; ++AI) {
1807 if (AI != BD->param_begin()) OS << ", ";
Chris Lattner39f34e92008-11-24 04:00:27 +00001808 ParamStr = (*AI)->getNameAsString();
Douglas Gregord249e1d1f2009-05-29 20:38:28 +00001809 (*AI)->getType().getAsStringInternal(ParamStr, Policy);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001810 OS << ParamStr;
1811 }
Mike Stump1eb44332009-09-09 15:08:12 +00001812
Douglas Gregor72564e72009-02-26 23:50:07 +00001813 const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001814 if (FT->isVariadic()) {
Steve Naroff56ee6892008-10-08 17:01:13 +00001815 if (!BD->param_empty()) OS << ", ";
Steve Naroff4eb206b2008-09-03 18:15:37 +00001816 OS << "...";
1817 }
1818 OS << ')';
1819 }
1820}
1821
Ted Kremenek381c0662011-11-30 22:08:08 +00001822void StmtPrinter::VisitOpaqueValueExpr(OpaqueValueExpr *Node) {
1823 PrintExpr(Node->getSourceExpr());
1824}
John McCall7cd7d1a2010-11-15 23:31:06 +00001825
Tanya Lattner61eee0c2011-06-04 00:47:47 +00001826void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) {
1827 OS << "__builtin_astype(";
1828 PrintExpr(Node->getSrcExpr());
1829 OS << ", " << Node->getType().getAsString();
1830 OS << ")";
1831}
1832
Reid Spencer5f016e22007-07-11 17:01:13 +00001833//===----------------------------------------------------------------------===//
1834// Stmt method implementations
1835//===----------------------------------------------------------------------===//
1836
Richard Smithd1420c62012-08-16 03:56:14 +00001837void Stmt::dumpPretty(ASTContext &Context) const {
1838 printPretty(llvm::errs(), 0, PrintingPolicy(Context.getLangOpts()));
Reid Spencer5f016e22007-07-11 17:01:13 +00001839}
1840
Richard Smithd1420c62012-08-16 03:56:14 +00001841void Stmt::printPretty(raw_ostream &OS,
1842 PrinterHelper *Helper,
Douglas Gregord249e1d1f2009-05-29 20:38:28 +00001843 const PrintingPolicy &Policy,
1844 unsigned Indentation) const {
Reid Spencer5f016e22007-07-11 17:01:13 +00001845 if (this == 0) {
1846 OS << "<NULL>";
1847 return;
1848 }
1849
Richard Smithd1420c62012-08-16 03:56:14 +00001850 if (Policy.DumpSourceManager) {
1851 dump(OS, *Policy.DumpSourceManager);
Douglas Gregor4fe0c8e2009-05-30 00:08:05 +00001852 return;
1853 }
Mike Stump1eb44332009-09-09 15:08:12 +00001854
Richard Smithd1420c62012-08-16 03:56:14 +00001855 StmtPrinter P(OS, Helper, Policy, Indentation);
Chris Lattnerc5598cb2007-08-21 04:04:25 +00001856 P.Visit(const_cast<Stmt*>(this));
Reid Spencer5f016e22007-07-11 17:01:13 +00001857}
Ted Kremenek42a509f2007-08-31 21:30:12 +00001858
1859//===----------------------------------------------------------------------===//
1860// PrinterHelper
1861//===----------------------------------------------------------------------===//
1862
1863// Implement virtual destructor.
Gabor Greif84675832007-09-11 15:32:40 +00001864PrinterHelper::~PrinterHelper() {}