lib/AST/StmtPrinter.cpp

   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, 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
 668 bool 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
 687 void StmtPrinter::VisitUnaryOffsetOf(UnaryOperator *Node) {
 688   OS << "__builtin_offsetof(";
 689   PrintOffsetOfDesignator(Node->getSubExpr());
 690   OS << ")";
 691 }
 692
 693 void 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 }
 702 void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) {
 703   PrintExpr(Node->getLHS());
 704   OS << "[";
 705   PrintExpr(Node->getRHS());
 706   OS << "]";
 707 }
 708
 709 void 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 }
 723 void 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 }
 731 void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
 732   PrintExpr(Node->getBase());
 733   OS << ".";
 734   OS << Node->getAccessor().getName();
 735 }
 736 void StmtPrinter::VisitCastExpr(CastExpr *) {
 737   assert(0 && "CastExpr is an abstract class");
 738 }
 739 void StmtPrinter::VisitExplicitCastExpr(ExplicitCastExpr *) {
 740   assert(0 && "ExplicitCastExpr is an abstract class");
 741 }
 742 void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) {
 743   OS << "(" << Node->getType().getAsString() << ")";
 744   PrintExpr(Node->getSubExpr());
 745 }
 746 void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) {
 747   OS << "(" << Node->getType().getAsString() << ")";
 748   PrintExpr(Node->getInitializer());
 749 }
 750 void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
 751   // No need to print anything, simply forward to the sub expression.
 752   PrintExpr(Node->getSubExpr());
 753 }
 754 void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) {
 755   PrintExpr(Node->getLHS());
 756   OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
 757   PrintExpr(Node->getRHS());
 758 }
 759 void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
 760   PrintExpr(Node->getLHS());
 761   OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
 762   PrintExpr(Node->getRHS());
 763 }
 764 void 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
 781 void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) {
 782   OS << "&&" << Node->getLabel()->getName();
 783 }
 784
 785 void StmtPrinter::VisitStmtExpr(StmtExpr *E) {
 786   OS << "(";
 787   PrintRawCompoundStmt(E->getSubStmt());
 788   OS << ")";
 789 }
 790
 791 void StmtPrinter::VisitTypesCompatibleExpr(TypesCompatibleExpr *Node) {
 792   OS << "__builtin_types_compatible_p(";
 793   OS << Node->getArgType1().getAsString() << ",";
 794   OS << Node->getArgType2().getAsString() << ")";
 795 }
 796
 797 void 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
 807 void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {
 808   OS << "__null";
 809 }
 810
 811 void 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
 820 void 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
 837 void 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
 863 void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) {
 864   if (Policy.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
 875 void 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++
 884 void 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
 928 void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) {
 929   VisitCallExpr(cast<CallExpr>(Node));
 930 }
 931
 932 void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
 933   OS << Node->getCastName() << '<';
 934   OS << Node->getTypeAsWritten().getAsString() << ">(";
 935   PrintExpr(Node->getSubExpr());
 936   OS << ")";
 937 }
 938
 939 void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) {
 940   VisitCXXNamedCastExpr(Node);
 941 }
 942
 943 void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) {
 944   VisitCXXNamedCastExpr(Node);
 945 }
 946
 947 void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
 948   VisitCXXNamedCastExpr(Node);
 949 }
 950
 951 void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
 952   VisitCXXNamedCastExpr(Node);
 953 }
 954
 955 void 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
 965 void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
 966   OS << (Node->getValue() ? "true" : "false");
 967 }
 968
 969 void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) {
 970   OS << "nullptr";
 971 }
 972
 973 void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) {
 974   OS << "this";
 975 }
 976
 977 void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) {
 978   if (Node->getSubExpr() == 0)
 979     OS << "throw";
 980   else {
 981     OS << "throw ";
 982     PrintExpr(Node->getSubExpr());
 983   }
 984 }
 985
 986 void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
 987   // Nothing to print: we picked up the default argument
 988 }
 989
 990 void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
 991   OS << Node->getType().getAsString();
 992   OS << "(";
 993   PrintExpr(Node->getSubExpr());
 994   OS << ")";
 995 }
 996
 997 void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
 998   PrintExpr(Node->getSubExpr());
 999 }
1000
1001 void 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
1014 void StmtPrinter::VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *Node) {
1015   OS << Node->getType().getAsString() << "()";
1016 }
1017
1018 void
1019 StmtPrinter::VisitCXXConditionDeclExpr(CXXConditionDeclExpr *E) {
1020   PrintRawDecl(E->getVarDecl());
1021 }
1022
1023 void 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
1065 void 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
1074 void StmtPrinter::VisitUnresolvedFunctionNameExpr(UnresolvedFunctionNameExpr *E) {
1075   OS << E->getName().getAsString();
1076 }
1077
1078 void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1079   // Nothing to print.
1080 }
1081
1082 void StmtPrinter::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) {
1083   // Just forward to the sub expression.
1084   PrintExpr(E->getSubExpr());
1085 }
1086
1087 void
1088 StmtPrinter::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
1102 void StmtPrinter::VisitCXXUnresolvedMemberExpr(CXXUnresolvedMemberExpr *Node) {
1103   PrintExpr(Node->getBase());
1104   OS << (Node->isArrow() ? "->" : ".");
1105   OS << Node->getMember().getAsString();
1106 }
1107
1108 static 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
1129 void StmtPrinter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1130   OS << getTypeTraitName(E->getTrait()) << "("
1131      << E->getQueriedType().getAsString() << ")";
1132 }
1133
1134 // Obj-C
1135
1136 void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) {
1137   OS << "@";
1138   VisitStringLiteral(Node->getString());
1139 }
1140
1141 void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
1142   OS << "@encode(" << Node->getEncodedType().getAsString() << ')';
1143 }
1144
1145 void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
1146   OS << "@selector(" << Node->getSelector().getAsString() << ')';
1147 }
1148
1149 void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
1150   OS << "@protocol(" << Node->getProtocol()->getNameAsString() << ')';
1151 }
1152
1153 void 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
1179 void StmtPrinter::VisitObjCSuperExpr(ObjCSuperExpr *) {
1180   OS << "super";
1181 }
1182
1183 void 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
1211 void StmtPrinter::VisitBlockDeclRefExpr(BlockDeclRefExpr *Node) {
1212   OS << Node->getDecl()->getNameAsString();
1213 }
1214 //===----------------------------------------------------------------------===//
1215 // Stmt method implementations
1216 //===----------------------------------------------------------------------===//
1217
1218 void Stmt::dumpPretty(ASTContext& Context) const {
1219   printPretty(llvm::errs(), Context, 0, PrintingPolicy());
1220 }
1221
1222 void Stmt::printPretty(llvm::raw_ostream &OS, ASTContext& Context,
1223                        PrinterHelper* Helper,
1224                        const PrintingPolicy &Policy,
1225                        unsigned Indentation) const {
1226   if (this == 0) {
1227     OS << "<NULL>";
1228     return;
1229   }
1230
1231   if (Policy.Dump) {
1232     dump();
1233     return;
1234   }
1235
1236   StmtPrinter P(OS, Context, Helper, Policy, Indentation);
1237   P.Visit(const_cast<Stmt*>(this));
1238 }
1239
1240 //===----------------------------------------------------------------------===//
1241 // PrinterHelper
1242 //===----------------------------------------------------------------------===//
1243
1244 // Implement virtual destructor.
1245 PrinterHelper::~PrinterHelper() {}