1 //===--- StmtPrinter.cpp - Printing implementation for Stmt ASTs ----------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Stmt::dumpPretty/Stmt::printPretty methods, which
11 // pretty print the AST back out to C code.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/AST/StmtVisitor.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/PrettyPrinter.h"
19 #include "llvm/Support/Compiler.h"
20 #include "llvm/Support/Streams.h"
21 #include "llvm/Support/Format.h"
22 using namespace clang;
23 
24 //===----------------------------------------------------------------------===//
25 // StmtPrinter Visitor
26 //===----------------------------------------------------------------------===//
27 
28 namespace  {
29   class VISIBILITY_HIDDEN StmtPrinter : public StmtVisitor<StmtPrinter> {
30     llvm::raw_ostream &OS;
31     ASTContext &Context;
32     unsigned IndentLevel;
33     clang::PrinterHelper* Helper;
34     PrintingPolicy Policy;
35 
36   public:
37     StmtPrinter(llvm::raw_ostream &os, ASTContext &C, PrinterHelper* helper,
38                 const PrintingPolicy &Policy = PrintingPolicy(),
39                 unsigned Indentation = 0)
40       : OS(os), Context(C), IndentLevel(Indentation), Helper(helper),
41         Policy(Policy) {}
42 
43     void PrintStmt(Stmt *S) {
44       PrintStmt(S, Policy.Indentation);
45     }
46 
47     void PrintStmt(Stmt *S, int SubIndent) {
48       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();
52         Visit(S);
53         OS << ";\n";
54       } else if (S) {
55         Visit(S);
56       } else {
57         Indent() << "<<<NULL STATEMENT>>>\n";
58       }
59       IndentLevel -= SubIndent;
60     }
61 
62     void PrintRawCompoundStmt(CompoundStmt *S);
63     void PrintRawDecl(Decl *D);
64     void PrintRawDeclStmt(DeclStmt *S);
65     void PrintRawIfStmt(IfStmt *If);
66     void PrintRawCXXCatchStmt(CXXCatchStmt *Catch);
67 
68     void PrintExpr(Expr *E) {
69       if (E)
70         Visit(E);
71       else
72         OS << "<null expr>";
73     }
74 
75     llvm::raw_ostream &Indent(int Delta = 0) {
76       for (int i = 0, e = IndentLevel+Delta; i < e; ++i)
77         OS << "  ";
78       return OS;
79     }
80 
81     bool PrintOffsetOfDesignator(Expr *E);
82     void VisitUnaryOffsetOf(UnaryOperator *Node);
83 
84     void Visit(Stmt* S) {
85       if (Helper && Helper->handledStmt(S,OS))
86           return;
87       else StmtVisitor<StmtPrinter>::Visit(S);
88     }
89 
90     void VisitStmt(Stmt *Node);
91 #define STMT(CLASS, PARENT) \
92     void Visit##CLASS(CLASS *Node);
93 #include "clang/AST/StmtNodes.def"
94   };
95 }
96 
97 //===----------------------------------------------------------------------===//
98 //  Stmt printing methods.
99 //===----------------------------------------------------------------------===//
100 
101 void StmtPrinter::VisitStmt(Stmt *Node) {
102   Indent() << "<<unknown stmt type>>\n";
103 }
104 
105 /// PrintRawCompoundStmt - Print a compound stmt without indenting the {, and
106 /// with no newline after the }.
107 void StmtPrinter::PrintRawCompoundStmt(CompoundStmt *Node) {
108   OS << "{\n";
109   for (CompoundStmt::body_iterator I = Node->body_begin(), E = Node->body_end();
110        I != E; ++I)
111     PrintStmt(*I);
112 
113   Indent() << "}";
114 }
115 
116 void StmtPrinter::PrintRawDecl(Decl *D) {
117   D->print(OS, Context, Policy, IndentLevel);
118 }
119 
120 void StmtPrinter::PrintRawDeclStmt(DeclStmt *S) {
121   DeclStmt::decl_iterator Begin = S->decl_begin(), End = S->decl_end();
122   llvm::SmallVector<Decl*, 2> Decls;
123   for ( ; Begin != End; ++Begin)
124     Decls.push_back(*Begin);
125 
126   Decl::printGroup(Decls.data(), Decls.size(), OS, Context, Policy,
127                    IndentLevel);
128 }
129 
130 void StmtPrinter::VisitNullStmt(NullStmt *Node) {
131   Indent() << ";\n";
132 }
133 
134 void StmtPrinter::VisitDeclStmt(DeclStmt *Node) {
135   Indent();
136   PrintRawDeclStmt(Node);
137   OS << ";\n";
138 }
139 
140 void StmtPrinter::VisitCompoundStmt(CompoundStmt *Node) {
141   Indent();
142   PrintRawCompoundStmt(Node);
143   OS << "\n";
144 }
145 
146 void StmtPrinter::VisitCaseStmt(CaseStmt *Node) {
147   Indent(-1) << "case ";
148   PrintExpr(Node->getLHS());
149   if (Node->getRHS()) {
150     OS << " ... ";
151     PrintExpr(Node->getRHS());
152   }
153   OS << ":\n";
154 
155   PrintStmt(Node->getSubStmt(), 0);
156 }
157 
158 void StmtPrinter::VisitDefaultStmt(DefaultStmt *Node) {
159   Indent(-1) << "default:\n";
160   PrintStmt(Node->getSubStmt(), 0);
161 }
162 
163 void StmtPrinter::VisitLabelStmt(LabelStmt *Node) {
164   Indent(-1) << Node->getName() << ":\n";
165   PrintStmt(Node->getSubStmt(), 0);
166 }
167 
168 void StmtPrinter::PrintRawIfStmt(IfStmt *If) {
169   OS << "if (";
170   PrintExpr(If->getCond());
171   OS << ')';
172 
173   if (CompoundStmt *CS = dyn_cast<CompoundStmt>(If->getThen())) {
174     OS << ' ';
175     PrintRawCompoundStmt(CS);
176     OS << (If->getElse() ? ' ' : '\n');
177   } else {
178     OS << '\n';
179     PrintStmt(If->getThen());
180     if (If->getElse()) Indent();
181   }
182 
183   if (Stmt *Else = If->getElse()) {
184     OS << "else";
185 
186     if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Else)) {
187       OS << ' ';
188       PrintRawCompoundStmt(CS);
189       OS << '\n';
190     } else if (IfStmt *ElseIf = dyn_cast<IfStmt>(Else)) {
191       OS << ' ';
192       PrintRawIfStmt(ElseIf);
193     } else {
194       OS << '\n';
195       PrintStmt(If->getElse());
196     }
197   }
198 }
199 
200 void StmtPrinter::VisitIfStmt(IfStmt *If) {
201   Indent();
202   PrintRawIfStmt(If);
203 }
204 
205 void StmtPrinter::VisitSwitchStmt(SwitchStmt *Node) {
206   Indent() << "switch (";
207   PrintExpr(Node->getCond());
208   OS << ")";
209 
210   // Pretty print compoundstmt bodies (very common).
211   if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
212     OS << " ";
213     PrintRawCompoundStmt(CS);
214     OS << "\n";
215   } else {
216     OS << "\n";
217     PrintStmt(Node->getBody());
218   }
219 }
220 
221 void StmtPrinter::VisitSwitchCase(SwitchCase*) {
222   assert(0 && "SwitchCase is an abstract class");
223 }
224 
225 void StmtPrinter::VisitWhileStmt(WhileStmt *Node) {
226   Indent() << "while (";
227   PrintExpr(Node->getCond());
228   OS << ")\n";
229   PrintStmt(Node->getBody());
230 }
231 
232 void StmtPrinter::VisitDoStmt(DoStmt *Node) {
233   Indent() << "do ";
234   if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
235     PrintRawCompoundStmt(CS);
236     OS << " ";
237   } else {
238     OS << "\n";
239     PrintStmt(Node->getBody());
240     Indent();
241   }
242 
243   OS << "while (";
244   PrintExpr(Node->getCond());
245   OS << ");\n";
246 }
247 
248 void StmtPrinter::VisitForStmt(ForStmt *Node) {
249   Indent() << "for (";
250   if (Node->getInit()) {
251     if (DeclStmt *DS = dyn_cast<DeclStmt>(Node->getInit()))
252       PrintRawDeclStmt(DS);
253     else
254       PrintExpr(cast<Expr>(Node->getInit()));
255   }
256   OS << ";";
257   if (Node->getCond()) {
258     OS << " ";
259     PrintExpr(Node->getCond());
260   }
261   OS << ";";
262   if (Node->getInc()) {
263     OS << " ";
264     PrintExpr(Node->getInc());
265   }
266   OS << ") ";
267 
268   if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
269     PrintRawCompoundStmt(CS);
270     OS << "\n";
271   } else {
272     OS << "\n";
273     PrintStmt(Node->getBody());
274   }
275 }
276 
277 void StmtPrinter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *Node) {
278   Indent() << "for (";
279   if (DeclStmt *DS = dyn_cast<DeclStmt>(Node->getElement()))
280     PrintRawDeclStmt(DS);
281   else
282     PrintExpr(cast<Expr>(Node->getElement()));
283   OS << " in ";
284   PrintExpr(Node->getCollection());
285   OS << ") ";
286 
287   if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
288     PrintRawCompoundStmt(CS);
289     OS << "\n";
290   } else {
291     OS << "\n";
292     PrintStmt(Node->getBody());
293   }
294 }
295 
296 void StmtPrinter::VisitGotoStmt(GotoStmt *Node) {
297   Indent() << "goto " << Node->getLabel()->getName() << ";\n";
298 }
299 
300 void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) {
301   Indent() << "goto *";
302   PrintExpr(Node->getTarget());
303   OS << ";\n";
304 }
305 
306 void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) {
307   Indent() << "continue;\n";
308 }
309 
310 void StmtPrinter::VisitBreakStmt(BreakStmt *Node) {
311   Indent() << "break;\n";
312 }
313 
314 
315 void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) {
316   Indent() << "return";
317   if (Node->getRetValue()) {
318     OS << " ";
319     PrintExpr(Node->getRetValue());
320   }
321   OS << ";\n";
322 }
323 
324 
325 void StmtPrinter::VisitAsmStmt(AsmStmt *Node) {
326   Indent() << "asm ";
327 
328   if (Node->isVolatile())
329     OS << "volatile ";
330 
331   OS << "(";
332   VisitStringLiteral(Node->getAsmString());
333 
334   // Outputs
335   if (Node->getNumOutputs() != 0 || Node->getNumInputs() != 0 ||
336       Node->getNumClobbers() != 0)
337     OS << " : ";
338 
339   for (unsigned i = 0, e = Node->getNumOutputs(); i != e; ++i) {
340     if (i != 0)
341       OS << ", ";
342 
343     if (!Node->getOutputName(i).empty()) {
344       OS << '[';
345       OS << Node->getOutputName(i);
346       OS << "] ";
347     }
348 
349     VisitStringLiteral(Node->getOutputConstraintLiteral(i));
350     OS << " ";
351     Visit(Node->getOutputExpr(i));
352   }
353 
354   // Inputs
355   if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0)
356     OS << " : ";
357 
358   for (unsigned i = 0, e = Node->getNumInputs(); i != e; ++i) {
359     if (i != 0)
360       OS << ", ";
361 
362     if (!Node->getInputName(i).empty()) {
363       OS << '[';
364       OS << Node->getInputName(i);
365       OS << "] ";
366     }
367 
368     VisitStringLiteral(Node->getInputConstraintLiteral(i));
369     OS << " ";
370     Visit(Node->getInputExpr(i));
371   }
372 
373   // Clobbers
374   if (Node->getNumClobbers() != 0)
375     OS << " : ";
376 
377   for (unsigned i = 0, e = Node->getNumClobbers(); i != e; ++i) {
378     if (i != 0)
379       OS << ", ";
380 
381     VisitStringLiteral(Node->getClobber(i));
382   }
383 
384   OS << ");\n";
385 }
386 
387 void StmtPrinter::VisitObjCAtTryStmt(ObjCAtTryStmt *Node) {
388   Indent() << "@try";
389   if (CompoundStmt *TS = dyn_cast<CompoundStmt>(Node->getTryBody())) {
390     PrintRawCompoundStmt(TS);
391     OS << "\n";
392   }
393 
394   for (ObjCAtCatchStmt *catchStmt =
395          static_cast<ObjCAtCatchStmt *>(Node->getCatchStmts());
396        catchStmt;
397        catchStmt =
398          static_cast<ObjCAtCatchStmt *>(catchStmt->getNextCatchStmt())) {
399     Indent() << "@catch(";
400     if (catchStmt->getCatchParamDecl()) {
401       if (Decl *DS = catchStmt->getCatchParamDecl())
402         PrintRawDecl(DS);
403     }
404     OS << ")";
405     if (CompoundStmt *CS = dyn_cast<CompoundStmt>(catchStmt->getCatchBody()))
406       {
407         PrintRawCompoundStmt(CS);
408         OS << "\n";
409       }
410   }
411 
412   if (ObjCAtFinallyStmt *FS =static_cast<ObjCAtFinallyStmt *>(
413           Node->getFinallyStmt())) {
414     Indent() << "@finally";
415     PrintRawCompoundStmt(dyn_cast<CompoundStmt>(FS->getFinallyBody()));
416     OS << "\n";
417   }
418 }
419 
420 void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) {
421 }
422 
423 void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) {
424   Indent() << "@catch (...) { /* todo */ } \n";
425 }
426 
427 void StmtPrinter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *Node) {
428   Indent() << "@throw";
429   if (Node->getThrowExpr()) {
430     OS << " ";
431     PrintExpr(Node->getThrowExpr());
432   }
433   OS << ";\n";
434 }
435 
436 void StmtPrinter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *Node) {
437   Indent() << "@synchronized (";
438   PrintExpr(Node->getSynchExpr());
439   OS << ")";
440   PrintRawCompoundStmt(Node->getSynchBody());
441   OS << "\n";
442 }
443 
444 void StmtPrinter::PrintRawCXXCatchStmt(CXXCatchStmt *Node) {
445   OS << "catch (";
446   if (Decl *ExDecl = Node->getExceptionDecl())
447     PrintRawDecl(ExDecl);
448   else
449     OS << "...";
450   OS << ") ";
451   PrintRawCompoundStmt(cast<CompoundStmt>(Node->getHandlerBlock()));
452 }
453 
454 void StmtPrinter::VisitCXXCatchStmt(CXXCatchStmt *Node) {
455   Indent();
456   PrintRawCXXCatchStmt(Node);
457   OS << "\n";
458 }
459 
460 void StmtPrinter::VisitCXXTryStmt(CXXTryStmt *Node) {
461   Indent() << "try ";
462   PrintRawCompoundStmt(Node->getTryBlock());
463   for(unsigned i = 0, e = Node->getNumHandlers(); i < e; ++i) {
464     OS << " ";
465     PrintRawCXXCatchStmt(Node->getHandler(i));
466   }
467   OS << "\n";
468 }
469 
470 //===----------------------------------------------------------------------===//
471 //  Expr printing methods.
472 //===----------------------------------------------------------------------===//
473 
474 void StmtPrinter::VisitExpr(Expr *Node) {
475   OS << "<<unknown expr type>>";
476 }
477 
478 void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
479   OS << Node->getDecl()->getNameAsString();
480 }
481 
482 void StmtPrinter::VisitQualifiedDeclRefExpr(QualifiedDeclRefExpr *Node) {
483   NamedDecl *D = Node->getDecl();
484 
485   Node->getQualifier()->print(OS, Policy);
486   OS << D->getNameAsString();
487 }
488 
489 void StmtPrinter::VisitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *Node) {
490   Node->getQualifier()->print(OS, Policy);
491   OS << Node->getDeclName().getAsString();
492 }
493 
494 void StmtPrinter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
495   if (Node->getBase()) {
496     PrintExpr(Node->getBase());
497     OS << (Node->isArrow() ? "->" : ".");
498   }
499   OS << Node->getDecl()->getNameAsString();
500 }
501 
502 void StmtPrinter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
503   if (Node->getBase()) {
504     PrintExpr(Node->getBase());
505     OS << ".";
506   }
507   OS << Node->getProperty()->getNameAsCString();
508 }
509 
510 void StmtPrinter::VisitObjCKVCRefExpr(ObjCKVCRefExpr *Node) {
511   if (Node->getBase()) {
512     PrintExpr(Node->getBase());
513     OS << ".";
514   }
515   // FIXME: Setter/Getter names
516 }
517 
518 void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) {
519   switch (Node->getIdentType()) {
520     default:
521       assert(0 && "unknown case");
522     case PredefinedExpr::Func:
523       OS << "__func__";
524       break;
525     case PredefinedExpr::Function:
526       OS << "__FUNCTION__";
527       break;
528     case PredefinedExpr::PrettyFunction:
529       OS << "__PRETTY_FUNCTION__";
530       break;
531   }
532 }
533 
534 void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) {
535   unsigned value = Node->getValue();
536   if (Node->isWide())
537     OS << "L";
538   switch (value) {
539   case '\\':
540     OS << "'\\\\'";
541     break;
542   case '\'':
543     OS << "'\\''";
544     break;
545   case '\a':
546     // TODO: K&R: the meaning of '\\a' is different in traditional C
547     OS << "'\\a'";
548     break;
549   case '\b':
550     OS << "'\\b'";
551     break;
552   // Nonstandard escape sequence.
553   /*case '\e':
554     OS << "'\\e'";
555     break;*/
556   case '\f':
557     OS << "'\\f'";
558     break;
559   case '\n':
560     OS << "'\\n'";
561     break;
562   case '\r':
563     OS << "'\\r'";
564     break;
565   case '\t':
566     OS << "'\\t'";
567     break;
568   case '\v':
569     OS << "'\\v'";
570     break;
571   default:
572     if (value < 256 && isprint(value)) {
573       OS << "'" << (char)value << "'";
574     } else if (value < 256) {
575       OS << "'\\x" << llvm::format("%x", value) << "'";
576     } else {
577       // FIXME what to really do here?
578       OS << value;
579     }
580   }
581 }
582 
583 void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) {
584   bool isSigned = Node->getType()->isSignedIntegerType();
585   OS << Node->getValue().toString(10, isSigned);
586 
587   // Emit suffixes.  Integer literals are always a builtin integer type.
588   switch (Node->getType()->getAsBuiltinType()->getKind()) {
589   default: assert(0 && "Unexpected type for integer literal!");
590   case BuiltinType::Int:       break; // no suffix.
591   case BuiltinType::UInt:      OS << 'U'; break;
592   case BuiltinType::Long:      OS << 'L'; break;
593   case BuiltinType::ULong:     OS << "UL"; break;
594   case BuiltinType::LongLong:  OS << "LL"; break;
595   case BuiltinType::ULongLong: OS << "ULL"; break;
596   }
597 }
598 void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) {
599   // FIXME: print value more precisely.
600   OS << Node->getValueAsApproximateDouble();
601 }
602 
603 void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) {
604   PrintExpr(Node->getSubExpr());
605   OS << "i";
606 }
607 
608 void StmtPrinter::VisitStringLiteral(StringLiteral *Str) {
609   if (Str->isWide()) OS << 'L';
610   OS << '"';
611 
612   // FIXME: this doesn't print wstrings right.
613   for (unsigned i = 0, e = Str->getByteLength(); i != e; ++i) {
614     unsigned char Char = Str->getStrData()[i];
615 
616     switch (Char) {
617     default:
618       if (isprint(Char))
619         OS << (char)Char;
620       else  // Output anything hard as an octal escape.
621         OS << '\\'
622         << (char)('0'+ ((Char >> 6) & 7))
623         << (char)('0'+ ((Char >> 3) & 7))
624         << (char)('0'+ ((Char >> 0) & 7));
625       break;
626     // Handle some common non-printable cases to make dumps prettier.
627     case '\\': OS << "\\\\"; break;
628     case '"': OS << "\\\""; break;
629     case '\n': OS << "\\n"; break;
630     case '\t': OS << "\\t"; break;
631     case '\a': OS << "\\a"; break;
632     case '\b': OS << "\\b"; break;
633     }
634   }
635   OS << '"';
636 }
637 void StmtPrinter::VisitParenExpr(ParenExpr *Node) {
638   OS << "(";
639   PrintExpr(Node->getSubExpr());
640   OS << ")";
641 }
642 void StmtPrinter::VisitUnaryOperator(UnaryOperator *Node) {
643   if (!Node->isPostfix()) {
644     OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
645 
646     // Print a space if this is an "identifier operator" like __real.
647     switch (Node->getOpcode()) {
648     default: break;
649     case UnaryOperator::Real:
650     case UnaryOperator::Imag:
651     case UnaryOperator::Extension:
652       OS << ' ';
653       break;
654     }
655   }
656   PrintExpr(Node->getSubExpr());
657 
658   if (Node->isPostfix())
659     OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
660 }
661 
662 bool StmtPrinter::PrintOffsetOfDesignator(Expr *E) {
663   if (isa<UnaryOperator>(E)) {
664     // Base case, print the type and comma.
665     OS << E->getType().getAsString() << ", ";
666     return true;
667   } else if (ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) {
668     PrintOffsetOfDesignator(ASE->getLHS());
669     OS << "[";
670     PrintExpr(ASE->getRHS());
671     OS << "]";
672     return false;
673   } else {
674     MemberExpr *ME = cast<MemberExpr>(E);
675     bool IsFirst = PrintOffsetOfDesignator(ME->getBase());
676     OS << (IsFirst ? "" : ".") << ME->getMemberDecl()->getNameAsString();
677     return false;
678   }
679 }
680 
681 void StmtPrinter::VisitUnaryOffsetOf(UnaryOperator *Node) {
682   OS << "__builtin_offsetof(";
683   PrintOffsetOfDesignator(Node->getSubExpr());
684   OS << ")";
685 }
686 
687 void StmtPrinter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *Node) {
688   OS << (Node->isSizeOf() ? "sizeof" : "__alignof");
689   if (Node->isArgumentType())
690     OS << "(" << Node->getArgumentType().getAsString() << ")";
691   else {
692     OS << " ";
693     PrintExpr(Node->getArgumentExpr());
694   }
695 }
696 void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) {
697   PrintExpr(Node->getLHS());
698   OS << "[";
699   PrintExpr(Node->getRHS());
700   OS << "]";
701 }
702 
703 void StmtPrinter::VisitCallExpr(CallExpr *Call) {
704   PrintExpr(Call->getCallee());
705   OS << "(";
706   for (unsigned i = 0, e = Call->getNumArgs(); i != e; ++i) {
707     if (isa<CXXDefaultArgExpr>(Call->getArg(i))) {
708       // Don't print any defaulted arguments
709       break;
710     }
711 
712     if (i) OS << ", ";
713     PrintExpr(Call->getArg(i));
714   }
715   OS << ")";
716 }
717 void StmtPrinter::VisitMemberExpr(MemberExpr *Node) {
718   // FIXME: Suppress printing implicit bases (like "this")
719   PrintExpr(Node->getBase());
720   OS << (Node->isArrow() ? "->" : ".");
721   // FIXME: Suppress printing references to unnamed objects
722   // representing anonymous unions/structs
723   OS << Node->getMemberDecl()->getNameAsString();
724 }
725 void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
726   PrintExpr(Node->getBase());
727   OS << ".";
728   OS << Node->getAccessor().getName();
729 }
730 void StmtPrinter::VisitCastExpr(CastExpr *) {
731   assert(0 && "CastExpr is an abstract class");
732 }
733 void StmtPrinter::VisitExplicitCastExpr(ExplicitCastExpr *) {
734   assert(0 && "ExplicitCastExpr is an abstract class");
735 }
736 void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) {
737   OS << "(" << Node->getType().getAsString() << ")";
738   PrintExpr(Node->getSubExpr());
739 }
740 void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) {
741   OS << "(" << Node->getType().getAsString() << ")";
742   PrintExpr(Node->getInitializer());
743 }
744 void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
745   // No need to print anything, simply forward to the sub expression.
746   PrintExpr(Node->getSubExpr());
747 }
748 void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) {
749   PrintExpr(Node->getLHS());
750   OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
751   PrintExpr(Node->getRHS());
752 }
753 void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
754   PrintExpr(Node->getLHS());
755   OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
756   PrintExpr(Node->getRHS());
757 }
758 void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) {
759   PrintExpr(Node->getCond());
760 
761   if (Node->getLHS()) {
762     OS << " ? ";
763     PrintExpr(Node->getLHS());
764     OS << " : ";
765   }
766   else { // Handle GCC extension where LHS can be NULL.
767     OS << " ?: ";
768   }
769 
770   PrintExpr(Node->getRHS());
771 }
772 
773 // GNU extensions.
774 
775 void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) {
776   OS << "&&" << Node->getLabel()->getName();
777 }
778 
779 void StmtPrinter::VisitStmtExpr(StmtExpr *E) {
780   OS << "(";
781   PrintRawCompoundStmt(E->getSubStmt());
782   OS << ")";
783 }
784 
785 void StmtPrinter::VisitTypesCompatibleExpr(TypesCompatibleExpr *Node) {
786   OS << "__builtin_types_compatible_p(";
787   OS << Node->getArgType1().getAsString() << ",";
788   OS << Node->getArgType2().getAsString() << ")";
789 }
790 
791 void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) {
792   OS << "__builtin_choose_expr(";
793   PrintExpr(Node->getCond());
794   OS << ", ";
795   PrintExpr(Node->getLHS());
796   OS << ", ";
797   PrintExpr(Node->getRHS());
798   OS << ")";
799 }
800 
801 void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {
802   OS << "__null";
803 }
804 
805 void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) {
806   OS << "__builtin_shufflevector(";
807   for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) {
808     if (i) OS << ", ";
809     PrintExpr(Node->getExpr(i));
810   }
811   OS << ")";
812 }
813 
814 void StmtPrinter::VisitInitListExpr(InitListExpr* Node) {
815   if (Node->getSyntacticForm()) {
816     Visit(Node->getSyntacticForm());
817     return;
818   }
819 
820   OS << "{ ";
821   for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) {
822     if (i) OS << ", ";
823     if (Node->getInit(i))
824       PrintExpr(Node->getInit(i));
825     else
826       OS << "0";
827   }
828   OS << " }";
829 }
830 
831 void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) {
832   for (DesignatedInitExpr::designators_iterator D = Node->designators_begin(),
833                       DEnd = Node->designators_end();
834        D != DEnd; ++D) {
835     if (D->isFieldDesignator()) {
836       if (D->getDotLoc().isInvalid())
837         OS << D->getFieldName()->getName() << ":";
838       else
839         OS << "." << D->getFieldName()->getName();
840     } else {
841       OS << "[";
842       if (D->isArrayDesignator()) {
843         PrintExpr(Node->getArrayIndex(*D));
844       } else {
845         PrintExpr(Node->getArrayRangeStart(*D));
846         OS << " ... ";
847         PrintExpr(Node->getArrayRangeEnd(*D));
848       }
849       OS << "]";
850     }
851   }
852 
853   OS << " = ";
854   PrintExpr(Node->getInit());
855 }
856 
857 void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) {
858   if (Policy.CPlusPlus)
859     OS << "/*implicit*/" << Node->getType().getAsString(Policy) << "()";
860   else {
861     OS << "/*implicit*/(" << Node->getType().getAsString(Policy) << ")";
862     if (Node->getType()->isRecordType())
863       OS << "{}";
864     else
865       OS << 0;
866   }
867 }
868 
869 void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) {
870   OS << "__builtin_va_arg(";
871   PrintExpr(Node->getSubExpr());
872   OS << ", ";
873   OS << Node->getType().getAsString();
874   OS << ")";
875 }
876 
877 // C++
878 void StmtPrinter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *Node) {
879   const char *OpStrings[NUM_OVERLOADED_OPERATORS] = {
880     "",
881 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
882     Spelling,
883 #include "clang/Basic/OperatorKinds.def"
884   };
885 
886   OverloadedOperatorKind Kind = Node->getOperator();
887   if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
888     if (Node->getNumArgs() == 1) {
889       OS << OpStrings[Kind] << ' ';
890       PrintExpr(Node->getArg(0));
891     } else {
892       PrintExpr(Node->getArg(0));
893       OS << ' ' << OpStrings[Kind];
894     }
895   } else if (Kind == OO_Call) {
896     PrintExpr(Node->getArg(0));
897     OS << '(';
898     for (unsigned ArgIdx = 1; ArgIdx < Node->getNumArgs(); ++ArgIdx) {
899       if (ArgIdx > 1)
900         OS << ", ";
901       if (!isa<CXXDefaultArgExpr>(Node->getArg(ArgIdx)))
902         PrintExpr(Node->getArg(ArgIdx));
903     }
904     OS << ')';
905   } else if (Kind == OO_Subscript) {
906     PrintExpr(Node->getArg(0));
907     OS << '[';
908     PrintExpr(Node->getArg(1));
909     OS << ']';
910   } else if (Node->getNumArgs() == 1) {
911     OS << OpStrings[Kind] << ' ';
912     PrintExpr(Node->getArg(0));
913   } else if (Node->getNumArgs() == 2) {
914     PrintExpr(Node->getArg(0));
915     OS << ' ' << OpStrings[Kind] << ' ';
916     PrintExpr(Node->getArg(1));
917   } else {
918     assert(false && "unknown overloaded operator");
919   }
920 }
921 
922 void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) {
923   VisitCallExpr(cast<CallExpr>(Node));
924 }
925 
926 void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
927   OS << Node->getCastName() << '<';
928   OS << Node->getTypeAsWritten().getAsString() << ">(";
929   PrintExpr(Node->getSubExpr());
930   OS << ")";
931 }
932 
933 void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) {
934   VisitCXXNamedCastExpr(Node);
935 }
936 
937 void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) {
938   VisitCXXNamedCastExpr(Node);
939 }
940 
941 void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
942   VisitCXXNamedCastExpr(Node);
943 }
944 
945 void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
946   VisitCXXNamedCastExpr(Node);
947 }
948 
949 void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) {
950   OS << "typeid(";
951   if (Node->isTypeOperand()) {
952     OS << Node->getTypeOperand().getAsString();
953   } else {
954     PrintExpr(Node->getExprOperand());
955   }
956   OS << ")";
957 }
958 
959 void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
960   OS << (Node->getValue() ? "true" : "false");
961 }
962 
963 void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) {
964   OS << "nullptr";
965 }
966 
967 void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) {
968   OS << "this";
969 }
970 
971 void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) {
972   if (Node->getSubExpr() == 0)
973     OS << "throw";
974   else {
975     OS << "throw ";
976     PrintExpr(Node->getSubExpr());
977   }
978 }
979 
980 void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
981   // Nothing to print: we picked up the default argument
982 }
983 
984 void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
985   OS << Node->getType().getAsString();
986   OS << "(";
987   PrintExpr(Node->getSubExpr());
988   OS << ")";
989 }
990 
991 void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
992   PrintExpr(Node->getSubExpr());
993 }
994 
995 void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) {
996   OS << Node->getType().getAsString();
997   OS << "(";
998   for (CXXTemporaryObjectExpr::arg_iterator Arg = Node->arg_begin(),
999                                          ArgEnd = Node->arg_end();
1000        Arg != ArgEnd; ++Arg) {
1001     if (Arg != Node->arg_begin())
1002       OS << ", ";
1003     PrintExpr(*Arg);
1004   }
1005   OS << ")";
1006 }
1007 
1008 void StmtPrinter::VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *Node) {
1009   OS << Node->getType().getAsString() << "()";
1010 }
1011 
1012 void
1013 StmtPrinter::VisitCXXConditionDeclExpr(CXXConditionDeclExpr *E) {
1014   PrintRawDecl(E->getVarDecl());
1015 }
1016 
1017 void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) {
1018   if (E->isGlobalNew())
1019     OS << "::";
1020   OS << "new ";
1021   unsigned NumPlace = E->getNumPlacementArgs();
1022   if (NumPlace > 0) {
1023     OS << "(";
1024     PrintExpr(E->getPlacementArg(0));
1025     for (unsigned i = 1; i < NumPlace; ++i) {
1026       OS << ", ";
1027       PrintExpr(E->getPlacementArg(i));
1028     }
1029     OS << ") ";
1030   }
1031   if (E->isParenTypeId())
1032     OS << "(";
1033   std::string TypeS;
1034   if (Expr *Size = E->getArraySize()) {
1035     llvm::raw_string_ostream s(TypeS);
1036     Size->printPretty(s, Context, Helper, Policy);
1037     s.flush();
1038     TypeS = "[" + TypeS + "]";
1039   }
1040   E->getAllocatedType().getAsStringInternal(TypeS, Policy);
1041   OS << TypeS;
1042   if (E->isParenTypeId())
1043     OS << ")";
1044 
1045   if (E->hasInitializer()) {
1046     OS << "(";
1047     unsigned NumCons = E->getNumConstructorArgs();
1048     if (NumCons > 0) {
1049       PrintExpr(E->getConstructorArg(0));
1050       for (unsigned i = 1; i < NumCons; ++i) {
1051         OS << ", ";
1052         PrintExpr(E->getConstructorArg(i));
1053       }
1054     }
1055     OS << ")";
1056   }
1057 }
1058 
1059 void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1060   if (E->isGlobalDelete())
1061     OS << "::";
1062   OS << "delete ";
1063   if (E->isArrayForm())
1064     OS << "[] ";
1065   PrintExpr(E->getArgument());
1066 }
1067 
1068 void StmtPrinter::VisitUnresolvedFunctionNameExpr(UnresolvedFunctionNameExpr *E) {
1069   OS << E->getName().getAsString();
1070 }
1071 
1072 void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1073   // Nothing to print.
1074 }
1075 
1076 void StmtPrinter::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) {
1077   // Just forward to the sub expression.
1078   PrintExpr(E->getSubExpr());
1079 }
1080 
1081 void
1082 StmtPrinter::VisitCXXUnresolvedConstructExpr(
1083                                            CXXUnresolvedConstructExpr *Node) {
1084   OS << Node->getTypeAsWritten().getAsString();
1085   OS << "(";
1086   for (CXXUnresolvedConstructExpr::arg_iterator Arg = Node->arg_begin(),
1087                                              ArgEnd = Node->arg_end();
1088        Arg != ArgEnd; ++Arg) {
1089     if (Arg != Node->arg_begin())
1090       OS << ", ";
1091     PrintExpr(*Arg);
1092   }
1093   OS << ")";
1094 }
1095 
1096 void StmtPrinter::VisitCXXUnresolvedMemberExpr(CXXUnresolvedMemberExpr *Node) {
1097   PrintExpr(Node->getBase());
1098   OS << (Node->isArrow() ? "->" : ".");
1099   OS << Node->getMember().getAsString();
1100 }
1101 
1102 static 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 
1123 void StmtPrinter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1124   OS << getTypeTraitName(E->getTrait()) << "("
1125      << E->getQueriedType().getAsString() << ")";
1126 }
1127 
1128 // Obj-C
1129 
1130 void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) {
1131   OS << "@";
1132   VisitStringLiteral(Node->getString());
1133 }
1134 
1135 void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
1136   OS << "@encode(" << Node->getEncodedType().getAsString() << ')';
1137 }
1138 
1139 void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
1140   OS << "@selector(" << Node->getSelector().getAsString() << ')';
1141 }
1142 
1143 void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
1144   OS << "@protocol(" << Node->getProtocol()->getNameAsString() << ')';
1145 }
1146 
1147 void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) {
1148   OS << "[";
1149   Expr *receiver = Mess->getReceiver();
1150   if (receiver) PrintExpr(receiver);
1151   else OS << Mess->getClassName()->getName();
1152   OS << ' ';
1153   Selector selector = Mess->getSelector();
1154   if (selector.isUnarySelector()) {
1155     OS << selector.getIdentifierInfoForSlot(0)->getName();
1156   } else {
1157     for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) {
1158       if (i < selector.getNumArgs()) {
1159         if (i > 0) OS << ' ';
1160         if (selector.getIdentifierInfoForSlot(i))
1161           OS << selector.getIdentifierInfoForSlot(i)->getName() << ':';
1162         else
1163            OS << ":";
1164       }
1165       else OS << ", "; // Handle variadic methods.
1166 
1167       PrintExpr(Mess->getArg(i));
1168     }
1169   }
1170   OS << "]";
1171 }
1172 
1173 void StmtPrinter::VisitObjCSuperExpr(ObjCSuperExpr *) {
1174   OS << "super";
1175 }
1176 
1177 void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
1178   BlockDecl *BD = Node->getBlockDecl();
1179   OS << "^";
1180 
1181   const FunctionType *AFT = Node->getFunctionType();
1182 
1183   if (isa<FunctionNoProtoType>(AFT)) {
1184     OS << "()";
1185   } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) {
1186     OS << '(';
1187     std::string ParamStr;
1188     for (BlockDecl::param_iterator AI = BD->param_begin(),
1189          E = BD->param_end(); AI != E; ++AI) {
1190       if (AI != BD->param_begin()) OS << ", ";
1191       ParamStr = (*AI)->getNameAsString();
1192       (*AI)->getType().getAsStringInternal(ParamStr, Policy);
1193       OS << ParamStr;
1194     }
1195 
1196     const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
1197     if (FT->isVariadic()) {
1198       if (!BD->param_empty()) OS << ", ";
1199       OS << "...";
1200     }
1201     OS << ')';
1202   }
1203 }
1204 
1205 void StmtPrinter::VisitBlockDeclRefExpr(BlockDeclRefExpr *Node) {
1206   OS << Node->getDecl()->getNameAsString();
1207 }
1208 //===----------------------------------------------------------------------===//
1209 // Stmt method implementations
1210 //===----------------------------------------------------------------------===//
1211 
1212 void Stmt::dumpPretty(ASTContext& Context) const {
1213   printPretty(llvm::errs(), Context, 0, PrintingPolicy());
1214 }
1215 
1216 void Stmt::printPretty(llvm::raw_ostream &OS, ASTContext& Context,
1217                        PrinterHelper* Helper,
1218                        const PrintingPolicy &Policy,
1219                        unsigned Indentation) const {
1220   if (this == 0) {
1221     OS << "<NULL>";
1222     return;
1223   }
1224 
1225   if (Policy.Dump) {
1226     dump();
1227     return;
1228   }
1229 
1230   StmtPrinter P(OS, Context, Helper, Policy, Indentation);
1231   P.Visit(const_cast<Stmt*>(this));
1232 }
1233 
1234 //===----------------------------------------------------------------------===//
1235 // PrinterHelper
1236 //===----------------------------------------------------------------------===//
1237 
1238 // Implement virtual destructor.
1239 PrinterHelper::~PrinterHelper() {}
1240