StmtPrinter.cpp revision 48d14a222276fad5279e994d1a062f36ae6fcbce 
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 = 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
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.
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
662bool 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
681void StmtPrinter::VisitUnaryOffsetOf(UnaryOperator *Node) {
682  OS << "__builtin_offsetof(";
683  PrintOffsetOfDesignator(Node->getSubExpr());
684  OS << ")";
685}
686
687void 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}
696void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) {
697  PrintExpr(Node->getLHS());
698  OS << "[";
699  PrintExpr(Node->getRHS());
700  OS << "]";
701}
702
703void 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}
717void 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}
725void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
726  PrintExpr(Node->getBase());
727  OS << ".";
728  OS << Node->getAccessor().getName();
729}
730void StmtPrinter::VisitCastExpr(CastExpr *) {
731  assert(0 && "CastExpr is an abstract class");
732}
733void StmtPrinter::VisitExplicitCastExpr(ExplicitCastExpr *) {
734  assert(0 && "ExplicitCastExpr is an abstract class");
735}
736void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) {
737  OS << "(" << Node->getType().getAsString() << ")";
738  PrintExpr(Node->getSubExpr());
739}
740void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) {
741  OS << "(" << Node->getType().getAsString() << ")";
742  PrintExpr(Node->getInitializer());
743}
744void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
745  // No need to print anything, simply forward to the sub expression.
746  PrintExpr(Node->getSubExpr());
747}
748void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) {
749  PrintExpr(Node->getLHS());
750  OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
751  PrintExpr(Node->getRHS());
752}
753void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
754  PrintExpr(Node->getLHS());
755  OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
756  PrintExpr(Node->getRHS());
757}
758void 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
775void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) {
776  OS << "&&" << Node->getLabel()->getName();
777}
778
779void StmtPrinter::VisitStmtExpr(StmtExpr *E) {
780  OS << "(";
781  PrintRawCompoundStmt(E->getSubStmt());
782  OS << ")";
783}
784
785void StmtPrinter::VisitTypesCompatibleExpr(TypesCompatibleExpr *Node) {
786  OS << "__builtin_types_compatible_p(";
787  OS << Node->getArgType1().getAsString() << ",";
788  OS << Node->getArgType2().getAsString() << ")";
789}
790
791void 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
801void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {
802  OS << "__null";
803}
804
805void 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
814void 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
831void 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
857void 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
869void 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++
878void 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
922void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) {
923  VisitCallExpr(cast<CallExpr>(Node));
924}
925
926void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
927  OS << Node->getCastName() << '<';
928  OS << Node->getTypeAsWritten().getAsString() << ">(";
929  PrintExpr(Node->getSubExpr());
930  OS << ")";
931}
932
933void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) {
934  VisitCXXNamedCastExpr(Node);
935}
936
937void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) {
938  VisitCXXNamedCastExpr(Node);
939}
940
941void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
942  VisitCXXNamedCastExpr(Node);
943}
944
945void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
946  VisitCXXNamedCastExpr(Node);
947}
948
949void 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
959void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
960  OS << (Node->getValue() ? "true" : "false");
961}
962
963void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) {
964  OS << "nullptr";
965}
966
967void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) {
968  OS << "this";
969}
970
971void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) {
972  if (Node->getSubExpr() == 0)
973    OS << "throw";
974  else {
975    OS << "throw ";
976    PrintExpr(Node->getSubExpr());
977  }
978}
979
980void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
981  // Nothing to print: we picked up the default argument
982}
983
984void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
985  OS << Node->getType().getAsString();
986  OS << "(";
987  PrintExpr(Node->getSubExpr());
988  OS << ")";
989}
990
991void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) {
992  OS << Node->getType().getAsString();
993  OS << "(";
994  for (CXXTemporaryObjectExpr::arg_iterator Arg = Node->arg_begin(),
995                                         ArgEnd = Node->arg_end();
996       Arg != ArgEnd; ++Arg) {
997    if (Arg != Node->arg_begin())
998      OS << ", ";
999    PrintExpr(*Arg);
1000  }
1001  OS << ")";
1002}
1003
1004void StmtPrinter::VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *Node) {
1005  OS << Node->getType().getAsString() << "()";
1006}
1007
1008void
1009StmtPrinter::VisitCXXConditionDeclExpr(CXXConditionDeclExpr *E) {
1010  PrintRawDecl(E->getVarDecl());
1011}
1012
1013void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) {
1014  if (E->isGlobalNew())
1015    OS << "::";
1016  OS << "new ";
1017  unsigned NumPlace = E->getNumPlacementArgs();
1018  if (NumPlace > 0) {
1019    OS << "(";
1020    PrintExpr(E->getPlacementArg(0));
1021    for (unsigned i = 1; i < NumPlace; ++i) {
1022      OS << ", ";
1023      PrintExpr(E->getPlacementArg(i));
1024    }
1025    OS << ") ";
1026  }
1027  if (E->isParenTypeId())
1028    OS << "(";
1029  std::string TypeS;
1030  if (Expr *Size = E->getArraySize()) {
1031    llvm::raw_string_ostream s(TypeS);
1032    Size->printPretty(s, Helper, Policy);
1033    s.flush();
1034    TypeS = "[" + TypeS + "]";
1035  }
1036  E->getAllocatedType().getAsStringInternal(TypeS, Policy);
1037  OS << TypeS;
1038  if (E->isParenTypeId())
1039    OS << ")";
1040
1041  if (E->hasInitializer()) {
1042    OS << "(";
1043    unsigned NumCons = E->getNumConstructorArgs();
1044    if (NumCons > 0) {
1045      PrintExpr(E->getConstructorArg(0));
1046      for (unsigned i = 1; i < NumCons; ++i) {
1047        OS << ", ";
1048        PrintExpr(E->getConstructorArg(i));
1049      }
1050    }
1051    OS << ")";
1052  }
1053}
1054
1055void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1056  if (E->isGlobalDelete())
1057    OS << "::";
1058  OS << "delete ";
1059  if (E->isArrayForm())
1060    OS << "[] ";
1061  PrintExpr(E->getArgument());
1062}
1063
1064void StmtPrinter::VisitUnresolvedFunctionNameExpr(UnresolvedFunctionNameExpr *E) {
1065  OS << E->getName().getAsString();
1066}
1067
1068void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1069  // Nothing to print.
1070}
1071
1072void StmtPrinter::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) {
1073  // Just forward to the sub expression.
1074  PrintExpr(E->getSubExpr());
1075}
1076
1077void
1078StmtPrinter::VisitCXXUnresolvedConstructExpr(
1079                                           CXXUnresolvedConstructExpr *Node) {
1080  OS << Node->getTypeAsWritten().getAsString();
1081  OS << "(";
1082  for (CXXUnresolvedConstructExpr::arg_iterator Arg = Node->arg_begin(),
1083                                             ArgEnd = Node->arg_end();
1084       Arg != ArgEnd; ++Arg) {
1085    if (Arg != Node->arg_begin())
1086      OS << ", ";
1087    PrintExpr(*Arg);
1088  }
1089  OS << ")";
1090}
1091
1092void StmtPrinter::VisitCXXUnresolvedMemberExpr(CXXUnresolvedMemberExpr *Node) {
1093  PrintExpr(Node->getBase());
1094  OS << (Node->isArrow() ? "->" : ".");
1095  OS << Node->getMember().getAsString();
1096}
1097
1098static const char *getTypeTraitName(UnaryTypeTrait UTT) {
1099  switch (UTT) {
1100  default: assert(false && "Unknown type trait");
1101  case UTT_HasNothrowAssign:      return "__has_nothrow_assign";
1102  case UTT_HasNothrowCopy:        return "__has_nothrow_copy";
1103  case UTT_HasNothrowConstructor: return "__has_nothrow_constructor";
1104  case UTT_HasTrivialAssign:      return "__has_trivial_assign";
1105  case UTT_HasTrivialCopy:        return "__has_trivial_copy";
1106  case UTT_HasTrivialConstructor: return "__has_trivial_constructor";
1107  case UTT_HasTrivialDestructor:  return "__has_trivial_destructor";
1108  case UTT_HasVirtualDestructor:  return "__has_virtual_destructor";
1109  case UTT_IsAbstract:            return "__is_abstract";
1110  case UTT_IsClass:               return "__is_class";
1111  case UTT_IsEmpty:               return "__is_empty";
1112  case UTT_IsEnum:                return "__is_enum";
1113  case UTT_IsPOD:                 return "__is_pod";
1114  case UTT_IsPolymorphic:         return "__is_polymorphic";
1115  case UTT_IsUnion:               return "__is_union";
1116  }
1117}
1118
1119void StmtPrinter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1120  OS << getTypeTraitName(E->getTrait()) << "("
1121     << E->getQueriedType().getAsString() << ")";
1122}
1123
1124// Obj-C
1125
1126void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) {
1127  OS << "@";
1128  VisitStringLiteral(Node->getString());
1129}
1130
1131void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
1132  OS << "@encode(" << Node->getEncodedType().getAsString() << ')';
1133}
1134
1135void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
1136  OS << "@selector(" << Node->getSelector().getAsString() << ')';
1137}
1138
1139void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
1140  OS << "@protocol(" << Node->getProtocol()->getNameAsString() << ')';
1141}
1142
1143void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) {
1144  OS << "[";
1145  Expr *receiver = Mess->getReceiver();
1146  if (receiver) PrintExpr(receiver);
1147  else OS << Mess->getClassName()->getName();
1148  OS << ' ';
1149  Selector selector = Mess->getSelector();
1150  if (selector.isUnarySelector()) {
1151    OS << selector.getIdentifierInfoForSlot(0)->getName();
1152  } else {
1153    for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) {
1154      if (i < selector.getNumArgs()) {
1155        if (i > 0) OS << ' ';
1156        if (selector.getIdentifierInfoForSlot(i))
1157          OS << selector.getIdentifierInfoForSlot(i)->getName() << ':';
1158        else
1159           OS << ":";
1160      }
1161      else OS << ", "; // Handle variadic methods.
1162
1163      PrintExpr(Mess->getArg(i));
1164    }
1165  }
1166  OS << "]";
1167}
1168
1169void StmtPrinter::VisitObjCSuperExpr(ObjCSuperExpr *) {
1170  OS << "super";
1171}
1172
1173void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
1174  BlockDecl *BD = Node->getBlockDecl();
1175  OS << "^";
1176
1177  const FunctionType *AFT = Node->getFunctionType();
1178
1179  if (isa<FunctionNoProtoType>(AFT)) {
1180    OS << "()";
1181  } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) {
1182    OS << '(';
1183    std::string ParamStr;
1184    for (BlockDecl::param_iterator AI = BD->param_begin(),
1185         E = BD->param_end(); AI != E; ++AI) {
1186      if (AI != BD->param_begin()) OS << ", ";
1187      ParamStr = (*AI)->getNameAsString();
1188      (*AI)->getType().getAsStringInternal(ParamStr, Policy);
1189      OS << ParamStr;
1190    }
1191
1192    const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
1193    if (FT->isVariadic()) {
1194      if (!BD->param_empty()) OS << ", ";
1195      OS << "...";
1196    }
1197    OS << ')';
1198  }
1199}
1200
1201void StmtPrinter::VisitBlockDeclRefExpr(BlockDeclRefExpr *Node) {
1202  OS << Node->getDecl()->getNameAsString();
1203}
1204//===----------------------------------------------------------------------===//
1205// Stmt method implementations
1206//===----------------------------------------------------------------------===//
1207
1208void Stmt::dumpPretty(ASTContext& Context) const {
1209  printPretty(llvm::errs(), Context, 0, PrintingPolicy());
1210}
1211
1212void Stmt::printPretty(llvm::raw_ostream &OS, ASTContext& Context,
1213                       PrinterHelper* Helper,
1214                       const PrintingPolicy &Policy,
1215                       unsigned Indentation) const {
1216  if (this == 0) {
1217    OS << "<NULL>";
1218    return;
1219  }
1220
1221  if (Policy.Dump) {
1222    dump();
1223    return;
1224  }
1225
1226  StmtPrinter P(OS, Context, Helper, Policy, Indentation);
1227  P.Visit(const_cast<Stmt*>(this));
1228}
1229
1230//===----------------------------------------------------------------------===//
1231// PrinterHelper
1232//===----------------------------------------------------------------------===//
1233
1234// Implement virtual destructor.
1235PrinterHelper::~PrinterHelper() {}
1236