StmtPrinter.cpp revision e4f2142d00fa5fdb580c4e2413da91882d955381 
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"
22using namespace clang;
23
24//===----------------------------------------------------------------------===//
25// StmtPrinter Visitor
26//===----------------------------------------------------------------------===//
27
28namespace  {
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,
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
101void 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 }.
107void 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
116void StmtPrinter::PrintRawDecl(Decl *D) {
117  D->print(OS, Context, Policy, IndentLevel);
118}
119
120void 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
130void StmtPrinter::VisitNullStmt(NullStmt *Node) {
131  Indent() << ";\n";
132}
133
134void StmtPrinter::VisitDeclStmt(DeclStmt *Node) {
135  Indent();
136  PrintRawDeclStmt(Node);
137  OS << ";\n";
138}
139
140void StmtPrinter::VisitCompoundStmt(CompoundStmt *Node) {
141  Indent();
142  PrintRawCompoundStmt(Node);
143  OS << "\n";
144}
145
146void 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
158void StmtPrinter::VisitDefaultStmt(DefaultStmt *Node) {
159  Indent(-1) << "default:\n";
160  PrintStmt(Node->getSubStmt(), 0);
161}
162
163void StmtPrinter::VisitLabelStmt(LabelStmt *Node) {
164  Indent(-1) << Node->getName() << ":\n";
165  PrintStmt(Node->getSubStmt(), 0);
166}
167
168void 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
200void StmtPrinter::VisitIfStmt(IfStmt *If) {
201  Indent();
202  PrintRawIfStmt(If);
203}
204
205void 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
221void StmtPrinter::VisitSwitchCase(SwitchCase*) {
222  assert(0 && "SwitchCase is an abstract class");
223}
224
225void StmtPrinter::VisitWhileStmt(WhileStmt *Node) {
226  Indent() << "while (";
227  PrintExpr(Node->getCond());
228  OS << ")\n";
229  PrintStmt(Node->getBody());
230}
231
232void 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
248void 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
277void 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
296void StmtPrinter::VisitGotoStmt(GotoStmt *Node) {
297  Indent() << "goto " << Node->getLabel()->getName() << ";\n";
298}
299
300void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) {
301  Indent() << "goto *";
302  PrintExpr(Node->getTarget());
303  OS << ";\n";
304}
305
306void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) {
307  Indent() << "continue;\n";
308}
309
310void StmtPrinter::VisitBreakStmt(BreakStmt *Node) {
311  Indent() << "break;\n";
312}
313
314
315void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) {
316  Indent() << "return";
317  if (Node->getRetValue()) {
318    OS << " ";
319    PrintExpr(Node->getRetValue());
320  }
321  OS << ";\n";
322}
323
324
325void 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
387void 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
420void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) {
421}
422
423void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) {
424  Indent() << "@catch (...) { /* todo */ } \n";
425}
426
427void StmtPrinter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *Node) {
428  Indent() << "@throw";
429  if (Node->getThrowExpr()) {
430    OS << " ";
431    PrintExpr(Node->getThrowExpr());
432  }
433  OS << ";\n";
434}
435
436void StmtPrinter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *Node) {
437  Indent() << "@synchronized (";
438  PrintExpr(Node->getSynchExpr());
439  OS << ")";
440  PrintRawCompoundStmt(Node->getSynchBody());
441  OS << "\n";
442}
443
444void 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
454void StmtPrinter::VisitCXXCatchStmt(CXXCatchStmt *Node) {
455  Indent();
456  PrintRawCXXCatchStmt(Node);
457  OS << "\n";
458}
459
460void 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
474void StmtPrinter::VisitExpr(Expr *Node) {
475  OS << "<<unknown expr type>>";
476}
477
478void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
479  OS << Node->getDecl()->getNameAsString();
480}
481
482void StmtPrinter::VisitQualifiedDeclRefExpr(QualifiedDeclRefExpr *Node) {
483  NamedDecl *D = Node->getDecl();
484
485  Node->getQualifier()->print(OS, Policy);
486  OS << D->getNameAsString();
487}
488
489void StmtPrinter::VisitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *Node) {
490  Node->getQualifier()->print(OS, Policy);
491  OS << Node->getDeclName().getAsString();
492}
493
494void StmtPrinter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
495  if (Node->getBase()) {
496    PrintExpr(Node->getBase());
497    OS << (Node->isArrow() ? "->" : ".");
498  }
499  OS << Node->getDecl()->getNameAsString();
500}
501
502void StmtPrinter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
503  if (Node->getBase()) {
504    PrintExpr(Node->getBase());
505    OS << ".";
506  }
507  OS << Node->getProperty()->getNameAsCString();
508}
509
510void StmtPrinter::VisitObjCKVCRefExpr(ObjCKVCRefExpr *Node) {
511  if (Node->getBase()) {
512    PrintExpr(Node->getBase());
513    OS << ".";
514  }
515  // FIXME: Setter/Getter names
516}
517
518void 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
534void 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
583void 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}
598void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) {
599  // FIXME: print value more precisely.
600  OS << Node->getValueAsApproximateDouble();
601}
602
603void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) {
604  PrintExpr(Node->getSubExpr());
605  OS << "i";
606}
607
608void 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}
637void StmtPrinter::VisitParenExpr(ParenExpr *Node) {
638  OS << "(";
639  PrintExpr(Node->getSubExpr());
640  OS << ")";
641}
642void 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, or if
647    // it might be concatenated incorrectly like '+'.
648    switch (Node->getOpcode()) {
649    default: break;
650    case UnaryOperator::Real:
651    case UnaryOperator::Imag:
652    case UnaryOperator::Extension:
653      OS << ' ';
654      break;
655    case UnaryOperator::Plus:
656    case UnaryOperator::Minus:
657      if (isa<UnaryOperator>(Node->getSubExpr()))
658        OS << ' ';
659      break;
660    }
661  }
662  PrintExpr(Node->getSubExpr());
663
664  if (Node->isPostfix())
665    OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
666}
667
668bool StmtPrinter::PrintOffsetOfDesignator(Expr *E) {
669  if (isa<UnaryOperator>(E)) {
670    // Base case, print the type and comma.
671    OS << E->getType().getAsString() << ", ";
672    return true;
673  } else if (ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) {
674    PrintOffsetOfDesignator(ASE->getLHS());
675    OS << "[";
676    PrintExpr(ASE->getRHS());
677    OS << "]";
678    return false;
679  } else {
680    MemberExpr *ME = cast<MemberExpr>(E);
681    bool IsFirst = PrintOffsetOfDesignator(ME->getBase());
682    OS << (IsFirst ? "" : ".") << ME->getMemberDecl()->getNameAsString();
683    return false;
684  }
685}
686
687void StmtPrinter::VisitUnaryOffsetOf(UnaryOperator *Node) {
688  OS << "__builtin_offsetof(";
689  PrintOffsetOfDesignator(Node->getSubExpr());
690  OS << ")";
691}
692
693void StmtPrinter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *Node) {
694  OS << (Node->isSizeOf() ? "sizeof" : "__alignof");
695  if (Node->isArgumentType())
696    OS << "(" << Node->getArgumentType().getAsString() << ")";
697  else {
698    OS << " ";
699    PrintExpr(Node->getArgumentExpr());
700  }
701}
702void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) {
703  PrintExpr(Node->getLHS());
704  OS << "[";
705  PrintExpr(Node->getRHS());
706  OS << "]";
707}
708
709void StmtPrinter::VisitCallExpr(CallExpr *Call) {
710  PrintExpr(Call->getCallee());
711  OS << "(";
712  for (unsigned i = 0, e = Call->getNumArgs(); i != e; ++i) {
713    if (isa<CXXDefaultArgExpr>(Call->getArg(i))) {
714      // Don't print any defaulted arguments
715      break;
716    }
717
718    if (i) OS << ", ";
719    PrintExpr(Call->getArg(i));
720  }
721  OS << ")";
722}
723void StmtPrinter::VisitMemberExpr(MemberExpr *Node) {
724  // FIXME: Suppress printing implicit bases (like "this")
725  PrintExpr(Node->getBase());
726  OS << (Node->isArrow() ? "->" : ".");
727  // FIXME: Suppress printing references to unnamed objects
728  // representing anonymous unions/structs
729  OS << Node->getMemberDecl()->getNameAsString();
730}
731void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
732  PrintExpr(Node->getBase());
733  OS << ".";
734  OS << Node->getAccessor().getName();
735}
736void StmtPrinter::VisitCastExpr(CastExpr *) {
737  assert(0 && "CastExpr is an abstract class");
738}
739void StmtPrinter::VisitExplicitCastExpr(ExplicitCastExpr *) {
740  assert(0 && "ExplicitCastExpr is an abstract class");
741}
742void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) {
743  OS << "(" << Node->getType().getAsString() << ")";
744  PrintExpr(Node->getSubExpr());
745}
746void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) {
747  OS << "(" << Node->getType().getAsString() << ")";
748  PrintExpr(Node->getInitializer());
749}
750void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
751  // No need to print anything, simply forward to the sub expression.
752  PrintExpr(Node->getSubExpr());
753}
754void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) {
755  PrintExpr(Node->getLHS());
756  OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
757  PrintExpr(Node->getRHS());
758}
759void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
760  PrintExpr(Node->getLHS());
761  OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
762  PrintExpr(Node->getRHS());
763}
764void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) {
765  PrintExpr(Node->getCond());
766
767  if (Node->getLHS()) {
768    OS << " ? ";
769    PrintExpr(Node->getLHS());
770    OS << " : ";
771  }
772  else { // Handle GCC extension where LHS can be NULL.
773    OS << " ?: ";
774  }
775
776  PrintExpr(Node->getRHS());
777}
778
779// GNU extensions.
780
781void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) {
782  OS << "&&" << Node->getLabel()->getName();
783}
784
785void StmtPrinter::VisitStmtExpr(StmtExpr *E) {
786  OS << "(";
787  PrintRawCompoundStmt(E->getSubStmt());
788  OS << ")";
789}
790
791void StmtPrinter::VisitTypesCompatibleExpr(TypesCompatibleExpr *Node) {
792  OS << "__builtin_types_compatible_p(";
793  OS << Node->getArgType1().getAsString() << ",";
794  OS << Node->getArgType2().getAsString() << ")";
795}
796
797void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) {
798  OS << "__builtin_choose_expr(";
799  PrintExpr(Node->getCond());
800  OS << ", ";
801  PrintExpr(Node->getLHS());
802  OS << ", ";
803  PrintExpr(Node->getRHS());
804  OS << ")";
805}
806
807void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {
808  OS << "__null";
809}
810
811void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) {
812  OS << "__builtin_shufflevector(";
813  for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) {
814    if (i) OS << ", ";
815    PrintExpr(Node->getExpr(i));
816  }
817  OS << ")";
818}
819
820void StmtPrinter::VisitInitListExpr(InitListExpr* Node) {
821  if (Node->getSyntacticForm()) {
822    Visit(Node->getSyntacticForm());
823    return;
824  }
825
826  OS << "{ ";
827  for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) {
828    if (i) OS << ", ";
829    if (Node->getInit(i))
830      PrintExpr(Node->getInit(i));
831    else
832      OS << "0";
833  }
834  OS << " }";
835}
836
837void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) {
838  for (DesignatedInitExpr::designators_iterator D = Node->designators_begin(),
839                      DEnd = Node->designators_end();
840       D != DEnd; ++D) {
841    if (D->isFieldDesignator()) {
842      if (D->getDotLoc().isInvalid())
843        OS << D->getFieldName()->getName() << ":";
844      else
845        OS << "." << D->getFieldName()->getName();
846    } else {
847      OS << "[";
848      if (D->isArrayDesignator()) {
849        PrintExpr(Node->getArrayIndex(*D));
850      } else {
851        PrintExpr(Node->getArrayRangeStart(*D));
852        OS << " ... ";
853        PrintExpr(Node->getArrayRangeEnd(*D));
854      }
855      OS << "]";
856    }
857  }
858
859  OS << " = ";
860  PrintExpr(Node->getInit());
861}
862
863void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) {
864  if (Policy.LangOpts.CPlusPlus)
865    OS << "/*implicit*/" << Node->getType().getAsString(Policy) << "()";
866  else {
867    OS << "/*implicit*/(" << Node->getType().getAsString(Policy) << ")";
868    if (Node->getType()->isRecordType())
869      OS << "{}";
870    else
871      OS << 0;
872  }
873}
874
875void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) {
876  OS << "__builtin_va_arg(";
877  PrintExpr(Node->getSubExpr());
878  OS << ", ";
879  OS << Node->getType().getAsString();
880  OS << ")";
881}
882
883// C++
884void StmtPrinter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *Node) {
885  const char *OpStrings[NUM_OVERLOADED_OPERATORS] = {
886    "",
887#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
888    Spelling,
889#include "clang/Basic/OperatorKinds.def"
890  };
891
892  OverloadedOperatorKind Kind = Node->getOperator();
893  if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
894    if (Node->getNumArgs() == 1) {
895      OS << OpStrings[Kind] << ' ';
896      PrintExpr(Node->getArg(0));
897    } else {
898      PrintExpr(Node->getArg(0));
899      OS << ' ' << OpStrings[Kind];
900    }
901  } else if (Kind == OO_Call) {
902    PrintExpr(Node->getArg(0));
903    OS << '(';
904    for (unsigned ArgIdx = 1; ArgIdx < Node->getNumArgs(); ++ArgIdx) {
905      if (ArgIdx > 1)
906        OS << ", ";
907      if (!isa<CXXDefaultArgExpr>(Node->getArg(ArgIdx)))
908        PrintExpr(Node->getArg(ArgIdx));
909    }
910    OS << ')';
911  } else if (Kind == OO_Subscript) {
912    PrintExpr(Node->getArg(0));
913    OS << '[';
914    PrintExpr(Node->getArg(1));
915    OS << ']';
916  } else if (Node->getNumArgs() == 1) {
917    OS << OpStrings[Kind] << ' ';
918    PrintExpr(Node->getArg(0));
919  } else if (Node->getNumArgs() == 2) {
920    PrintExpr(Node->getArg(0));
921    OS << ' ' << OpStrings[Kind] << ' ';
922    PrintExpr(Node->getArg(1));
923  } else {
924    assert(false && "unknown overloaded operator");
925  }
926}
927
928void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) {
929  VisitCallExpr(cast<CallExpr>(Node));
930}
931
932void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
933  OS << Node->getCastName() << '<';
934  OS << Node->getTypeAsWritten().getAsString() << ">(";
935  PrintExpr(Node->getSubExpr());
936  OS << ")";
937}
938
939void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) {
940  VisitCXXNamedCastExpr(Node);
941}
942
943void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) {
944  VisitCXXNamedCastExpr(Node);
945}
946
947void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
948  VisitCXXNamedCastExpr(Node);
949}
950
951void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
952  VisitCXXNamedCastExpr(Node);
953}
954
955void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) {
956  OS << "typeid(";
957  if (Node->isTypeOperand()) {
958    OS << Node->getTypeOperand().getAsString();
959  } else {
960    PrintExpr(Node->getExprOperand());
961  }
962  OS << ")";
963}
964
965void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
966  OS << (Node->getValue() ? "true" : "false");
967}
968
969void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) {
970  OS << "nullptr";
971}
972
973void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) {
974  OS << "this";
975}
976
977void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) {
978  if (Node->getSubExpr() == 0)
979    OS << "throw";
980  else {
981    OS << "throw ";
982    PrintExpr(Node->getSubExpr());
983  }
984}
985
986void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
987  // Nothing to print: we picked up the default argument
988}
989
990void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
991  OS << Node->getType().getAsString();
992  OS << "(";
993  PrintExpr(Node->getSubExpr());
994  OS << ")";
995}
996
997void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
998  PrintExpr(Node->getSubExpr());
999}
1000
1001void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) {
1002  OS << Node->getType().getAsString();
1003  OS << "(";
1004  for (CXXTemporaryObjectExpr::arg_iterator Arg = Node->arg_begin(),
1005                                         ArgEnd = Node->arg_end();
1006       Arg != ArgEnd; ++Arg) {
1007    if (Arg != Node->arg_begin())
1008      OS << ", ";
1009    PrintExpr(*Arg);
1010  }
1011  OS << ")";
1012}
1013
1014void StmtPrinter::VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *Node) {
1015  OS << Node->getType().getAsString() << "()";
1016}
1017
1018void
1019StmtPrinter::VisitCXXConditionDeclExpr(CXXConditionDeclExpr *E) {
1020  PrintRawDecl(E->getVarDecl());
1021}
1022
1023void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) {
1024  if (E->isGlobalNew())
1025    OS << "::";
1026  OS << "new ";
1027  unsigned NumPlace = E->getNumPlacementArgs();
1028  if (NumPlace > 0) {
1029    OS << "(";
1030    PrintExpr(E->getPlacementArg(0));
1031    for (unsigned i = 1; i < NumPlace; ++i) {
1032      OS << ", ";
1033      PrintExpr(E->getPlacementArg(i));
1034    }
1035    OS << ") ";
1036  }
1037  if (E->isParenTypeId())
1038    OS << "(";
1039  std::string TypeS;
1040  if (Expr *Size = E->getArraySize()) {
1041    llvm::raw_string_ostream s(TypeS);
1042    Size->printPretty(s, Context, Helper, Policy);
1043    s.flush();
1044    TypeS = "[" + TypeS + "]";
1045  }
1046  E->getAllocatedType().getAsStringInternal(TypeS, Policy);
1047  OS << TypeS;
1048  if (E->isParenTypeId())
1049    OS << ")";
1050
1051  if (E->hasInitializer()) {
1052    OS << "(";
1053    unsigned NumCons = E->getNumConstructorArgs();
1054    if (NumCons > 0) {
1055      PrintExpr(E->getConstructorArg(0));
1056      for (unsigned i = 1; i < NumCons; ++i) {
1057        OS << ", ";
1058        PrintExpr(E->getConstructorArg(i));
1059      }
1060    }
1061    OS << ")";
1062  }
1063}
1064
1065void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1066  if (E->isGlobalDelete())
1067    OS << "::";
1068  OS << "delete ";
1069  if (E->isArrayForm())
1070    OS << "[] ";
1071  PrintExpr(E->getArgument());
1072}
1073
1074void StmtPrinter::VisitUnresolvedFunctionNameExpr(UnresolvedFunctionNameExpr *E) {
1075  OS << E->getName().getAsString();
1076}
1077
1078void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1079  // Nothing to print.
1080}
1081
1082void StmtPrinter::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) {
1083  // Just forward to the sub expression.
1084  PrintExpr(E->getSubExpr());
1085}
1086
1087void
1088StmtPrinter::VisitCXXUnresolvedConstructExpr(
1089                                           CXXUnresolvedConstructExpr *Node) {
1090  OS << Node->getTypeAsWritten().getAsString();
1091  OS << "(";
1092  for (CXXUnresolvedConstructExpr::arg_iterator Arg = Node->arg_begin(),
1093                                             ArgEnd = Node->arg_end();
1094       Arg != ArgEnd; ++Arg) {
1095    if (Arg != Node->arg_begin())
1096      OS << ", ";
1097    PrintExpr(*Arg);
1098  }
1099  OS << ")";
1100}
1101
1102void StmtPrinter::VisitCXXUnresolvedMemberExpr(CXXUnresolvedMemberExpr *Node) {
1103  PrintExpr(Node->getBase());
1104  OS << (Node->isArrow() ? "->" : ".");
1105  OS << Node->getMember().getAsString();
1106}
1107
1108static const char *getTypeTraitName(UnaryTypeTrait UTT) {
1109  switch (UTT) {
1110  default: assert(false && "Unknown type trait");
1111  case UTT_HasNothrowAssign:      return "__has_nothrow_assign";
1112  case UTT_HasNothrowCopy:        return "__has_nothrow_copy";
1113  case UTT_HasNothrowConstructor: return "__has_nothrow_constructor";
1114  case UTT_HasTrivialAssign:      return "__has_trivial_assign";
1115  case UTT_HasTrivialCopy:        return "__has_trivial_copy";
1116  case UTT_HasTrivialConstructor: return "__has_trivial_constructor";
1117  case UTT_HasTrivialDestructor:  return "__has_trivial_destructor";
1118  case UTT_HasVirtualDestructor:  return "__has_virtual_destructor";
1119  case UTT_IsAbstract:            return "__is_abstract";
1120  case UTT_IsClass:               return "__is_class";
1121  case UTT_IsEmpty:               return "__is_empty";
1122  case UTT_IsEnum:                return "__is_enum";
1123  case UTT_IsPOD:                 return "__is_pod";
1124  case UTT_IsPolymorphic:         return "__is_polymorphic";
1125  case UTT_IsUnion:               return "__is_union";
1126  }
1127}
1128
1129void StmtPrinter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1130  OS << getTypeTraitName(E->getTrait()) << "("
1131     << E->getQueriedType().getAsString() << ")";
1132}
1133
1134// Obj-C
1135
1136void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) {
1137  OS << "@";
1138  VisitStringLiteral(Node->getString());
1139}
1140
1141void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
1142  OS << "@encode(" << Node->getEncodedType().getAsString() << ')';
1143}
1144
1145void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
1146  OS << "@selector(" << Node->getSelector().getAsString() << ')';
1147}
1148
1149void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
1150  OS << "@protocol(" << Node->getProtocol()->getNameAsString() << ')';
1151}
1152
1153void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) {
1154  OS << "[";
1155  Expr *receiver = Mess->getReceiver();
1156  if (receiver) PrintExpr(receiver);
1157  else OS << Mess->getClassName()->getName();
1158  OS << ' ';
1159  Selector selector = Mess->getSelector();
1160  if (selector.isUnarySelector()) {
1161    OS << selector.getIdentifierInfoForSlot(0)->getName();
1162  } else {
1163    for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) {
1164      if (i < selector.getNumArgs()) {
1165        if (i > 0) OS << ' ';
1166        if (selector.getIdentifierInfoForSlot(i))
1167          OS << selector.getIdentifierInfoForSlot(i)->getName() << ':';
1168        else
1169           OS << ":";
1170      }
1171      else OS << ", "; // Handle variadic methods.
1172
1173      PrintExpr(Mess->getArg(i));
1174    }
1175  }
1176  OS << "]";
1177}
1178
1179void StmtPrinter::VisitObjCSuperExpr(ObjCSuperExpr *) {
1180  OS << "super";
1181}
1182
1183void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
1184  BlockDecl *BD = Node->getBlockDecl();
1185  OS << "^";
1186
1187  const FunctionType *AFT = Node->getFunctionType();
1188
1189  if (isa<FunctionNoProtoType>(AFT)) {
1190    OS << "()";
1191  } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) {
1192    OS << '(';
1193    std::string ParamStr;
1194    for (BlockDecl::param_iterator AI = BD->param_begin(),
1195         E = BD->param_end(); AI != E; ++AI) {
1196      if (AI != BD->param_begin()) OS << ", ";
1197      ParamStr = (*AI)->getNameAsString();
1198      (*AI)->getType().getAsStringInternal(ParamStr, Policy);
1199      OS << ParamStr;
1200    }
1201
1202    const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
1203    if (FT->isVariadic()) {
1204      if (!BD->param_empty()) OS << ", ";
1205      OS << "...";
1206    }
1207    OS << ')';
1208  }
1209}
1210
1211void StmtPrinter::VisitBlockDeclRefExpr(BlockDeclRefExpr *Node) {
1212  OS << Node->getDecl()->getNameAsString();
1213}
1214//===----------------------------------------------------------------------===//
1215// Stmt method implementations
1216//===----------------------------------------------------------------------===//
1217
1218void Stmt::dumpPretty(ASTContext& Context) const {
1219  printPretty(llvm::errs(), Context, 0,
1220              PrintingPolicy(Context.getLangOptions()));
1221}
1222
1223void Stmt::printPretty(llvm::raw_ostream &OS, ASTContext& Context,
1224                       PrinterHelper* Helper,
1225                       const PrintingPolicy &Policy,
1226                       unsigned Indentation) const {
1227  if (this == 0) {
1228    OS << "<NULL>";
1229    return;
1230  }
1231
1232  if (Policy.Dump) {
1233    dump();
1234    return;
1235  }
1236
1237  StmtPrinter P(OS, Context, Helper, Policy, Indentation);
1238  P.Visit(const_cast<Stmt*>(this));
1239}
1240
1241//===----------------------------------------------------------------------===//
1242// PrinterHelper
1243//===----------------------------------------------------------------------===//
1244
1245// Implement virtual destructor.
1246PrinterHelper::~PrinterHelper() {}
1247