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