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/DeclTemplate.h" 19 #include "clang/AST/PrettyPrinter.h" 20 #include "clang/AST/Expr.h" 21 #include "clang/AST/ExprCXX.h" 22 #include "llvm/ADT/SmallString.h" 23 using namespace clang; 24 25 //===----------------------------------------------------------------------===// 26 // StmtPrinter Visitor 27 //===----------------------------------------------------------------------===// 28 29 namespace { 30 class StmtPrinter : public StmtVisitor<StmtPrinter> { 31 raw_ostream &OS; 32 ASTContext &Context; 33 unsigned IndentLevel; 34 clang::PrinterHelper* Helper; 35 PrintingPolicy Policy; 36 37 public: 38 StmtPrinter(raw_ostream &os, ASTContext &C, PrinterHelper* helper, 39 const PrintingPolicy &Policy, 40 unsigned Indentation = 0) 41 : OS(os), Context(C), IndentLevel(Indentation), Helper(helper), 42 Policy(Policy) {} 43 44 void PrintStmt(Stmt *S) { 45 PrintStmt(S, Policy.Indentation); 46 } 47 48 void PrintStmt(Stmt *S, int SubIndent) { 49 IndentLevel += SubIndent; 50 if (S && isa<Expr>(S)) { 51 // If this is an expr used in a stmt context, indent and newline it. 52 Indent(); 53 Visit(S); 54 OS << ";\n"; 55 } else if (S) { 56 Visit(S); 57 } else { 58 Indent() << "<<<NULL STATEMENT>>>\n"; 59 } 60 IndentLevel -= SubIndent; 61 } 62 63 void PrintRawCompoundStmt(CompoundStmt *S); 64 void PrintRawDecl(Decl *D); 65 void PrintRawDeclStmt(DeclStmt *S); 66 void PrintRawIfStmt(IfStmt *If); 67 void PrintRawCXXCatchStmt(CXXCatchStmt *Catch); 68 void PrintCallArgs(CallExpr *E); 69 void PrintRawSEHExceptHandler(SEHExceptStmt *S); 70 void PrintRawSEHFinallyStmt(SEHFinallyStmt *S); 71 72 void PrintExpr(Expr *E) { 73 if (E) 74 Visit(E); 75 else 76 OS << "<null expr>"; 77 } 78 79 raw_ostream &Indent(int Delta = 0) { 80 for (int i = 0, e = IndentLevel+Delta; i < e; ++i) 81 OS << " "; 82 return OS; 83 } 84 85 void Visit(Stmt* S) { 86 if (Helper && Helper->handledStmt(S,OS)) 87 return; 88 else StmtVisitor<StmtPrinter>::Visit(S); 89 } 90 91 void VisitStmt(Stmt *Node) LLVM_ATTRIBUTE_UNUSED { 92 Indent() << "<<unknown stmt type>>\n"; 93 } 94 void VisitExpr(Expr *Node) LLVM_ATTRIBUTE_UNUSED { 95 OS << "<<unknown expr type>>"; 96 } 97 void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node); 98 99 #define ABSTRACT_STMT(CLASS) 100 #define STMT(CLASS, PARENT) \ 101 void Visit##CLASS(CLASS *Node); 102 #include "clang/AST/StmtNodes.inc" 103 }; 104 } 105 106 //===----------------------------------------------------------------------===// 107 // Stmt printing methods. 108 //===----------------------------------------------------------------------===// 109 110 /// PrintRawCompoundStmt - Print a compound stmt without indenting the {, and 111 /// with no newline after the }. 112 void StmtPrinter::PrintRawCompoundStmt(CompoundStmt *Node) { 113 OS << "{\n"; 114 for (CompoundStmt::body_iterator I = Node->body_begin(), E = Node->body_end(); 115 I != E; ++I) 116 PrintStmt(*I); 117 118 Indent() << "}"; 119 } 120 121 void StmtPrinter::PrintRawDecl(Decl *D) { 122 D->print(OS, Policy, IndentLevel); 123 } 124 125 void StmtPrinter::PrintRawDeclStmt(DeclStmt *S) { 126 DeclStmt::decl_iterator Begin = S->decl_begin(), End = S->decl_end(); 127 SmallVector<Decl*, 2> Decls; 128 for ( ; Begin != End; ++Begin) 129 Decls.push_back(*Begin); 130 131 Decl::printGroup(Decls.data(), Decls.size(), OS, Policy, IndentLevel); 132 } 133 134 void StmtPrinter::VisitNullStmt(NullStmt *Node) { 135 Indent() << ";\n"; 136 } 137 138 void StmtPrinter::VisitDeclStmt(DeclStmt *Node) { 139 Indent(); 140 PrintRawDeclStmt(Node); 141 OS << ";\n"; 142 } 143 144 void StmtPrinter::VisitCompoundStmt(CompoundStmt *Node) { 145 Indent(); 146 PrintRawCompoundStmt(Node); 147 OS << "\n"; 148 } 149 150 void StmtPrinter::VisitCaseStmt(CaseStmt *Node) { 151 Indent(-1) << "case "; 152 PrintExpr(Node->getLHS()); 153 if (Node->getRHS()) { 154 OS << " ... "; 155 PrintExpr(Node->getRHS()); 156 } 157 OS << ":\n"; 158 159 PrintStmt(Node->getSubStmt(), 0); 160 } 161 162 void StmtPrinter::VisitDefaultStmt(DefaultStmt *Node) { 163 Indent(-1) << "default:\n"; 164 PrintStmt(Node->getSubStmt(), 0); 165 } 166 167 void StmtPrinter::VisitLabelStmt(LabelStmt *Node) { 168 Indent(-1) << Node->getName() << ":\n"; 169 PrintStmt(Node->getSubStmt(), 0); 170 } 171 172 void StmtPrinter::VisitAttributedStmt(AttributedStmt *Node) { 173 OS << "[["; 174 bool first = true; 175 for (AttrVec::const_iterator it = Node->getAttrs().begin(), 176 end = Node->getAttrs().end(); 177 it != end; ++it) { 178 if (!first) { 179 OS << ", "; 180 first = false; 181 } 182 // TODO: check this 183 (*it)->printPretty(OS, Context); 184 } 185 OS << "]] "; 186 PrintStmt(Node->getSubStmt(), 0); 187 } 188 189 void StmtPrinter::PrintRawIfStmt(IfStmt *If) { 190 OS << "if ("; 191 PrintExpr(If->getCond()); 192 OS << ')'; 193 194 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(If->getThen())) { 195 OS << ' '; 196 PrintRawCompoundStmt(CS); 197 OS << (If->getElse() ? ' ' : '\n'); 198 } else { 199 OS << '\n'; 200 PrintStmt(If->getThen()); 201 if (If->getElse()) Indent(); 202 } 203 204 if (Stmt *Else = If->getElse()) { 205 OS << "else"; 206 207 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Else)) { 208 OS << ' '; 209 PrintRawCompoundStmt(CS); 210 OS << '\n'; 211 } else if (IfStmt *ElseIf = dyn_cast<IfStmt>(Else)) { 212 OS << ' '; 213 PrintRawIfStmt(ElseIf); 214 } else { 215 OS << '\n'; 216 PrintStmt(If->getElse()); 217 } 218 } 219 } 220 221 void StmtPrinter::VisitIfStmt(IfStmt *If) { 222 Indent(); 223 PrintRawIfStmt(If); 224 } 225 226 void StmtPrinter::VisitSwitchStmt(SwitchStmt *Node) { 227 Indent() << "switch ("; 228 PrintExpr(Node->getCond()); 229 OS << ")"; 230 231 // Pretty print compoundstmt bodies (very common). 232 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) { 233 OS << " "; 234 PrintRawCompoundStmt(CS); 235 OS << "\n"; 236 } else { 237 OS << "\n"; 238 PrintStmt(Node->getBody()); 239 } 240 } 241 242 void StmtPrinter::VisitWhileStmt(WhileStmt *Node) { 243 Indent() << "while ("; 244 PrintExpr(Node->getCond()); 245 OS << ")\n"; 246 PrintStmt(Node->getBody()); 247 } 248 249 void StmtPrinter::VisitDoStmt(DoStmt *Node) { 250 Indent() << "do "; 251 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) { 252 PrintRawCompoundStmt(CS); 253 OS << " "; 254 } else { 255 OS << "\n"; 256 PrintStmt(Node->getBody()); 257 Indent(); 258 } 259 260 OS << "while ("; 261 PrintExpr(Node->getCond()); 262 OS << ");\n"; 263 } 264 265 void StmtPrinter::VisitForStmt(ForStmt *Node) { 266 Indent() << "for ("; 267 if (Node->getInit()) { 268 if (DeclStmt *DS = dyn_cast<DeclStmt>(Node->getInit())) 269 PrintRawDeclStmt(DS); 270 else 271 PrintExpr(cast<Expr>(Node->getInit())); 272 } 273 OS << ";"; 274 if (Node->getCond()) { 275 OS << " "; 276 PrintExpr(Node->getCond()); 277 } 278 OS << ";"; 279 if (Node->getInc()) { 280 OS << " "; 281 PrintExpr(Node->getInc()); 282 } 283 OS << ") "; 284 285 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) { 286 PrintRawCompoundStmt(CS); 287 OS << "\n"; 288 } else { 289 OS << "\n"; 290 PrintStmt(Node->getBody()); 291 } 292 } 293 294 void StmtPrinter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *Node) { 295 Indent() << "for ("; 296 if (DeclStmt *DS = dyn_cast<DeclStmt>(Node->getElement())) 297 PrintRawDeclStmt(DS); 298 else 299 PrintExpr(cast<Expr>(Node->getElement())); 300 OS << " in "; 301 PrintExpr(Node->getCollection()); 302 OS << ") "; 303 304 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) { 305 PrintRawCompoundStmt(CS); 306 OS << "\n"; 307 } else { 308 OS << "\n"; 309 PrintStmt(Node->getBody()); 310 } 311 } 312 313 void StmtPrinter::VisitCXXForRangeStmt(CXXForRangeStmt *Node) { 314 Indent() << "for ("; 315 PrintingPolicy SubPolicy(Policy); 316 SubPolicy.SuppressInitializers = true; 317 Node->getLoopVariable()->print(OS, SubPolicy, IndentLevel); 318 OS << " : "; 319 PrintExpr(Node->getRangeInit()); 320 OS << ") {\n"; 321 PrintStmt(Node->getBody()); 322 Indent() << "}\n"; 323 } 324 325 void StmtPrinter::VisitMSDependentExistsStmt(MSDependentExistsStmt *Node) { 326 Indent(); 327 if (Node->isIfExists()) 328 OS << "__if_exists ("; 329 else 330 OS << "__if_not_exists ("; 331 332 if (NestedNameSpecifier *Qualifier 333 = Node->getQualifierLoc().getNestedNameSpecifier()) 334 Qualifier->print(OS, Policy); 335 336 OS << Node->getNameInfo() << ") "; 337 338 PrintRawCompoundStmt(Node->getSubStmt()); 339 } 340 341 void StmtPrinter::VisitGotoStmt(GotoStmt *Node) { 342 Indent() << "goto " << Node->getLabel()->getName() << ";\n"; 343 } 344 345 void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) { 346 Indent() << "goto *"; 347 PrintExpr(Node->getTarget()); 348 OS << ";\n"; 349 } 350 351 void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) { 352 Indent() << "continue;\n"; 353 } 354 355 void StmtPrinter::VisitBreakStmt(BreakStmt *Node) { 356 Indent() << "break;\n"; 357 } 358 359 360 void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) { 361 Indent() << "return"; 362 if (Node->getRetValue()) { 363 OS << " "; 364 PrintExpr(Node->getRetValue()); 365 } 366 OS << ";\n"; 367 } 368 369 370 void StmtPrinter::VisitAsmStmt(AsmStmt *Node) { 371 Indent() << "asm "; 372 373 if (Node->isVolatile()) 374 OS << "volatile "; 375 376 OS << "("; 377 VisitStringLiteral(Node->getAsmString()); 378 379 // Outputs 380 if (Node->getNumOutputs() != 0 || Node->getNumInputs() != 0 || 381 Node->getNumClobbers() != 0) 382 OS << " : "; 383 384 for (unsigned i = 0, e = Node->getNumOutputs(); i != e; ++i) { 385 if (i != 0) 386 OS << ", "; 387 388 if (!Node->getOutputName(i).empty()) { 389 OS << '['; 390 OS << Node->getOutputName(i); 391 OS << "] "; 392 } 393 394 VisitStringLiteral(Node->getOutputConstraintLiteral(i)); 395 OS << " "; 396 Visit(Node->getOutputExpr(i)); 397 } 398 399 // Inputs 400 if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0) 401 OS << " : "; 402 403 for (unsigned i = 0, e = Node->getNumInputs(); i != e; ++i) { 404 if (i != 0) 405 OS << ", "; 406 407 if (!Node->getInputName(i).empty()) { 408 OS << '['; 409 OS << Node->getInputName(i); 410 OS << "] "; 411 } 412 413 VisitStringLiteral(Node->getInputConstraintLiteral(i)); 414 OS << " "; 415 Visit(Node->getInputExpr(i)); 416 } 417 418 // Clobbers 419 if (Node->getNumClobbers() != 0) 420 OS << " : "; 421 422 for (unsigned i = 0, e = Node->getNumClobbers(); i != e; ++i) { 423 if (i != 0) 424 OS << ", "; 425 426 VisitStringLiteral(Node->getClobber(i)); 427 } 428 429 OS << ");\n"; 430 } 431 432 void StmtPrinter::VisitObjCAtTryStmt(ObjCAtTryStmt *Node) { 433 Indent() << "@try"; 434 if (CompoundStmt *TS = dyn_cast<CompoundStmt>(Node->getTryBody())) { 435 PrintRawCompoundStmt(TS); 436 OS << "\n"; 437 } 438 439 for (unsigned I = 0, N = Node->getNumCatchStmts(); I != N; ++I) { 440 ObjCAtCatchStmt *catchStmt = Node->getCatchStmt(I); 441 Indent() << "@catch("; 442 if (catchStmt->getCatchParamDecl()) { 443 if (Decl *DS = catchStmt->getCatchParamDecl()) 444 PrintRawDecl(DS); 445 } 446 OS << ")"; 447 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(catchStmt->getCatchBody())) { 448 PrintRawCompoundStmt(CS); 449 OS << "\n"; 450 } 451 } 452 453 if (ObjCAtFinallyStmt *FS = static_cast<ObjCAtFinallyStmt *>( 454 Node->getFinallyStmt())) { 455 Indent() << "@finally"; 456 PrintRawCompoundStmt(dyn_cast<CompoundStmt>(FS->getFinallyBody())); 457 OS << "\n"; 458 } 459 } 460 461 void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) { 462 } 463 464 void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) { 465 Indent() << "@catch (...) { /* todo */ } \n"; 466 } 467 468 void StmtPrinter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *Node) { 469 Indent() << "@throw"; 470 if (Node->getThrowExpr()) { 471 OS << " "; 472 PrintExpr(Node->getThrowExpr()); 473 } 474 OS << ";\n"; 475 } 476 477 void StmtPrinter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *Node) { 478 Indent() << "@synchronized ("; 479 PrintExpr(Node->getSynchExpr()); 480 OS << ")"; 481 PrintRawCompoundStmt(Node->getSynchBody()); 482 OS << "\n"; 483 } 484 485 void StmtPrinter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *Node) { 486 Indent() << "@autoreleasepool"; 487 PrintRawCompoundStmt(dyn_cast<CompoundStmt>(Node->getSubStmt())); 488 OS << "\n"; 489 } 490 491 void StmtPrinter::PrintRawCXXCatchStmt(CXXCatchStmt *Node) { 492 OS << "catch ("; 493 if (Decl *ExDecl = Node->getExceptionDecl()) 494 PrintRawDecl(ExDecl); 495 else 496 OS << "..."; 497 OS << ") "; 498 PrintRawCompoundStmt(cast<CompoundStmt>(Node->getHandlerBlock())); 499 } 500 501 void StmtPrinter::VisitCXXCatchStmt(CXXCatchStmt *Node) { 502 Indent(); 503 PrintRawCXXCatchStmt(Node); 504 OS << "\n"; 505 } 506 507 void StmtPrinter::VisitCXXTryStmt(CXXTryStmt *Node) { 508 Indent() << "try "; 509 PrintRawCompoundStmt(Node->getTryBlock()); 510 for (unsigned i = 0, e = Node->getNumHandlers(); i < e; ++i) { 511 OS << " "; 512 PrintRawCXXCatchStmt(Node->getHandler(i)); 513 } 514 OS << "\n"; 515 } 516 517 void StmtPrinter::VisitSEHTryStmt(SEHTryStmt *Node) { 518 Indent() << (Node->getIsCXXTry() ? "try " : "__try "); 519 PrintRawCompoundStmt(Node->getTryBlock()); 520 SEHExceptStmt *E = Node->getExceptHandler(); 521 SEHFinallyStmt *F = Node->getFinallyHandler(); 522 if(E) 523 PrintRawSEHExceptHandler(E); 524 else { 525 assert(F && "Must have a finally block..."); 526 PrintRawSEHFinallyStmt(F); 527 } 528 OS << "\n"; 529 } 530 531 void StmtPrinter::PrintRawSEHFinallyStmt(SEHFinallyStmt *Node) { 532 OS << "__finally "; 533 PrintRawCompoundStmt(Node->getBlock()); 534 OS << "\n"; 535 } 536 537 void StmtPrinter::PrintRawSEHExceptHandler(SEHExceptStmt *Node) { 538 OS << "__except ("; 539 VisitExpr(Node->getFilterExpr()); 540 OS << ")\n"; 541 PrintRawCompoundStmt(Node->getBlock()); 542 OS << "\n"; 543 } 544 545 void StmtPrinter::VisitSEHExceptStmt(SEHExceptStmt *Node) { 546 Indent(); 547 PrintRawSEHExceptHandler(Node); 548 OS << "\n"; 549 } 550 551 void StmtPrinter::VisitSEHFinallyStmt(SEHFinallyStmt *Node) { 552 Indent(); 553 PrintRawSEHFinallyStmt(Node); 554 OS << "\n"; 555 } 556 557 //===----------------------------------------------------------------------===// 558 // Expr printing methods. 559 //===----------------------------------------------------------------------===// 560 561 void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) { 562 if (NestedNameSpecifier *Qualifier = Node->getQualifier()) 563 Qualifier->print(OS, Policy); 564 if (Node->hasTemplateKeyword()) 565 OS << "template "; 566 OS << Node->getNameInfo(); 567 if (Node->hasExplicitTemplateArgs()) 568 OS << TemplateSpecializationType::PrintTemplateArgumentList( 569 Node->getTemplateArgs(), 570 Node->getNumTemplateArgs(), 571 Policy); 572 } 573 574 void StmtPrinter::VisitDependentScopeDeclRefExpr( 575 DependentScopeDeclRefExpr *Node) { 576 if (NestedNameSpecifier *Qualifier = Node->getQualifier()) 577 Qualifier->print(OS, Policy); 578 if (Node->hasTemplateKeyword()) 579 OS << "template "; 580 OS << Node->getNameInfo(); 581 if (Node->hasExplicitTemplateArgs()) 582 OS << TemplateSpecializationType::PrintTemplateArgumentList( 583 Node->getTemplateArgs(), 584 Node->getNumTemplateArgs(), 585 Policy); 586 } 587 588 void StmtPrinter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) { 589 if (Node->getQualifier()) 590 Node->getQualifier()->print(OS, Policy); 591 if (Node->hasTemplateKeyword()) 592 OS << "template "; 593 OS << Node->getNameInfo(); 594 if (Node->hasExplicitTemplateArgs()) 595 OS << TemplateSpecializationType::PrintTemplateArgumentList( 596 Node->getTemplateArgs(), 597 Node->getNumTemplateArgs(), 598 Policy); 599 } 600 601 void StmtPrinter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) { 602 if (Node->getBase()) { 603 PrintExpr(Node->getBase()); 604 OS << (Node->isArrow() ? "->" : "."); 605 } 606 OS << *Node->getDecl(); 607 } 608 609 void StmtPrinter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) { 610 if (Node->isSuperReceiver()) 611 OS << "super."; 612 else if (Node->getBase()) { 613 PrintExpr(Node->getBase()); 614 OS << "."; 615 } 616 617 if (Node->isImplicitProperty()) 618 OS << Node->getImplicitPropertyGetter()->getSelector().getAsString(); 619 else 620 OS << Node->getExplicitProperty()->getName(); 621 } 622 623 void StmtPrinter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *Node) { 624 625 PrintExpr(Node->getBaseExpr()); 626 OS << "["; 627 PrintExpr(Node->getKeyExpr()); 628 OS << "]"; 629 } 630 631 void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) { 632 switch (Node->getIdentType()) { 633 default: 634 llvm_unreachable("unknown case"); 635 case PredefinedExpr::Func: 636 OS << "__func__"; 637 break; 638 case PredefinedExpr::Function: 639 OS << "__FUNCTION__"; 640 break; 641 case PredefinedExpr::PrettyFunction: 642 OS << "__PRETTY_FUNCTION__"; 643 break; 644 } 645 } 646 647 void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) { 648 unsigned value = Node->getValue(); 649 650 switch (Node->getKind()) { 651 case CharacterLiteral::Ascii: break; // no prefix. 652 case CharacterLiteral::Wide: OS << 'L'; break; 653 case CharacterLiteral::UTF16: OS << 'u'; break; 654 case CharacterLiteral::UTF32: OS << 'U'; break; 655 } 656 657 switch (value) { 658 case '\\': 659 OS << "'\\\\'"; 660 break; 661 case '\'': 662 OS << "'\\''"; 663 break; 664 case '\a': 665 // TODO: K&R: the meaning of '\\a' is different in traditional C 666 OS << "'\\a'"; 667 break; 668 case '\b': 669 OS << "'\\b'"; 670 break; 671 // Nonstandard escape sequence. 672 /*case '\e': 673 OS << "'\\e'"; 674 break;*/ 675 case '\f': 676 OS << "'\\f'"; 677 break; 678 case '\n': 679 OS << "'\\n'"; 680 break; 681 case '\r': 682 OS << "'\\r'"; 683 break; 684 case '\t': 685 OS << "'\\t'"; 686 break; 687 case '\v': 688 OS << "'\\v'"; 689 break; 690 default: 691 if (value < 256 && isprint(value)) { 692 OS << "'" << (char)value << "'"; 693 } else if (value < 256) { 694 OS << "'\\x"; 695 OS.write_hex(value) << "'"; 696 } else { 697 // FIXME what to really do here? 698 OS << value; 699 } 700 } 701 } 702 703 void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) { 704 bool isSigned = Node->getType()->isSignedIntegerType(); 705 OS << Node->getValue().toString(10, isSigned); 706 707 // Emit suffixes. Integer literals are always a builtin integer type. 708 switch (Node->getType()->getAs<BuiltinType>()->getKind()) { 709 default: llvm_unreachable("Unexpected type for integer literal!"); 710 // FIXME: The Short and UShort cases are to handle cases where a short 711 // integeral literal is formed during template instantiation. They should 712 // be removed when template instantiation no longer needs integer literals. 713 case BuiltinType::Short: 714 case BuiltinType::UShort: 715 case BuiltinType::Int: break; // no suffix. 716 case BuiltinType::UInt: OS << 'U'; break; 717 case BuiltinType::Long: OS << 'L'; break; 718 case BuiltinType::ULong: OS << "UL"; break; 719 case BuiltinType::LongLong: OS << "LL"; break; 720 case BuiltinType::ULongLong: OS << "ULL"; break; 721 case BuiltinType::Int128: OS << "i128"; break; 722 case BuiltinType::UInt128: OS << "Ui128"; break; 723 } 724 } 725 void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) { 726 SmallString<16> Str; 727 Node->getValue().toString(Str); 728 OS << Str; 729 } 730 731 void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) { 732 PrintExpr(Node->getSubExpr()); 733 OS << "i"; 734 } 735 736 void StmtPrinter::VisitStringLiteral(StringLiteral *Str) { 737 switch (Str->getKind()) { 738 case StringLiteral::Ascii: break; // no prefix. 739 case StringLiteral::Wide: OS << 'L'; break; 740 case StringLiteral::UTF8: OS << "u8"; break; 741 case StringLiteral::UTF16: OS << 'u'; break; 742 case StringLiteral::UTF32: OS << 'U'; break; 743 } 744 OS << '"'; 745 static char Hex[] = "0123456789ABCDEF"; 746 747 unsigned LastSlashX = Str->getLength(); 748 for (unsigned I = 0, N = Str->getLength(); I != N; ++I) { 749 switch (uint32_t Char = Str->getCodeUnit(I)) { 750 default: 751 // FIXME: Convert UTF-8 back to codepoints before rendering. 752 753 // Convert UTF-16 surrogate pairs back to codepoints before rendering. 754 // Leave invalid surrogates alone; we'll use \x for those. 755 if (Str->getKind() == StringLiteral::UTF16 && I != N - 1 && 756 Char >= 0xd800 && Char <= 0xdbff) { 757 uint32_t Trail = Str->getCodeUnit(I + 1); 758 if (Trail >= 0xdc00 && Trail <= 0xdfff) { 759 Char = 0x10000 + ((Char - 0xd800) << 10) + (Trail - 0xdc00); 760 ++I; 761 } 762 } 763 764 if (Char > 0xff) { 765 // If this is a wide string, output characters over 0xff using \x 766 // escapes. Otherwise, this is a UTF-16 or UTF-32 string, and Char is a 767 // codepoint: use \x escapes for invalid codepoints. 768 if (Str->getKind() == StringLiteral::Wide || 769 (Char >= 0xd800 && Char <= 0xdfff) || Char >= 0x110000) { 770 // FIXME: Is this the best way to print wchar_t? 771 OS << "\\x"; 772 int Shift = 28; 773 while ((Char >> Shift) == 0) 774 Shift -= 4; 775 for (/**/; Shift >= 0; Shift -= 4) 776 OS << Hex[(Char >> Shift) & 15]; 777 LastSlashX = I; 778 break; 779 } 780 781 if (Char > 0xffff) 782 OS << "\\U00" 783 << Hex[(Char >> 20) & 15] 784 << Hex[(Char >> 16) & 15]; 785 else 786 OS << "\\u"; 787 OS << Hex[(Char >> 12) & 15] 788 << Hex[(Char >> 8) & 15] 789 << Hex[(Char >> 4) & 15] 790 << Hex[(Char >> 0) & 15]; 791 break; 792 } 793 794 // If we used \x... for the previous character, and this character is a 795 // hexadecimal digit, prevent it being slurped as part of the \x. 796 if (LastSlashX + 1 == I) { 797 switch (Char) { 798 case '0': case '1': case '2': case '3': case '4': 799 case '5': case '6': case '7': case '8': case '9': 800 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': 801 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': 802 OS << "\"\""; 803 } 804 } 805 806 if (Char <= 0xff && isprint(Char)) 807 OS << (char)Char; 808 else // Output anything hard as an octal escape. 809 OS << '\\' 810 << (char)('0' + ((Char >> 6) & 7)) 811 << (char)('0' + ((Char >> 3) & 7)) 812 << (char)('0' + ((Char >> 0) & 7)); 813 break; 814 // Handle some common non-printable cases to make dumps prettier. 815 case '\\': OS << "\\\\"; break; 816 case '"': OS << "\\\""; break; 817 case '\n': OS << "\\n"; break; 818 case '\t': OS << "\\t"; break; 819 case '\a': OS << "\\a"; break; 820 case '\b': OS << "\\b"; break; 821 } 822 } 823 OS << '"'; 824 } 825 void StmtPrinter::VisitParenExpr(ParenExpr *Node) { 826 OS << "("; 827 PrintExpr(Node->getSubExpr()); 828 OS << ")"; 829 } 830 void StmtPrinter::VisitUnaryOperator(UnaryOperator *Node) { 831 if (!Node->isPostfix()) { 832 OS << UnaryOperator::getOpcodeStr(Node->getOpcode()); 833 834 // Print a space if this is an "identifier operator" like __real, or if 835 // it might be concatenated incorrectly like '+'. 836 switch (Node->getOpcode()) { 837 default: break; 838 case UO_Real: 839 case UO_Imag: 840 case UO_Extension: 841 OS << ' '; 842 break; 843 case UO_Plus: 844 case UO_Minus: 845 if (isa<UnaryOperator>(Node->getSubExpr())) 846 OS << ' '; 847 break; 848 } 849 } 850 PrintExpr(Node->getSubExpr()); 851 852 if (Node->isPostfix()) 853 OS << UnaryOperator::getOpcodeStr(Node->getOpcode()); 854 } 855 856 void StmtPrinter::VisitOffsetOfExpr(OffsetOfExpr *Node) { 857 OS << "__builtin_offsetof("; 858 OS << Node->getTypeSourceInfo()->getType().getAsString(Policy) << ", "; 859 bool PrintedSomething = false; 860 for (unsigned i = 0, n = Node->getNumComponents(); i < n; ++i) { 861 OffsetOfExpr::OffsetOfNode ON = Node->getComponent(i); 862 if (ON.getKind() == OffsetOfExpr::OffsetOfNode::Array) { 863 // Array node 864 OS << "["; 865 PrintExpr(Node->getIndexExpr(ON.getArrayExprIndex())); 866 OS << "]"; 867 PrintedSomething = true; 868 continue; 869 } 870 871 // Skip implicit base indirections. 872 if (ON.getKind() == OffsetOfExpr::OffsetOfNode::Base) 873 continue; 874 875 // Field or identifier node. 876 IdentifierInfo *Id = ON.getFieldName(); 877 if (!Id) 878 continue; 879 880 if (PrintedSomething) 881 OS << "."; 882 else 883 PrintedSomething = true; 884 OS << Id->getName(); 885 } 886 OS << ")"; 887 } 888 889 void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node){ 890 switch(Node->getKind()) { 891 case UETT_SizeOf: 892 OS << "sizeof"; 893 break; 894 case UETT_AlignOf: 895 OS << "__alignof"; 896 break; 897 case UETT_VecStep: 898 OS << "vec_step"; 899 break; 900 } 901 if (Node->isArgumentType()) 902 OS << "(" << Node->getArgumentType().getAsString(Policy) << ")"; 903 else { 904 OS << " "; 905 PrintExpr(Node->getArgumentExpr()); 906 } 907 } 908 909 void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) { 910 OS << "_Generic("; 911 PrintExpr(Node->getControllingExpr()); 912 for (unsigned i = 0; i != Node->getNumAssocs(); ++i) { 913 OS << ", "; 914 QualType T = Node->getAssocType(i); 915 if (T.isNull()) 916 OS << "default"; 917 else 918 OS << T.getAsString(Policy); 919 OS << ": "; 920 PrintExpr(Node->getAssocExpr(i)); 921 } 922 OS << ")"; 923 } 924 925 void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) { 926 PrintExpr(Node->getLHS()); 927 OS << "["; 928 PrintExpr(Node->getRHS()); 929 OS << "]"; 930 } 931 932 void StmtPrinter::PrintCallArgs(CallExpr *Call) { 933 for (unsigned i = 0, e = Call->getNumArgs(); i != e; ++i) { 934 if (isa<CXXDefaultArgExpr>(Call->getArg(i))) { 935 // Don't print any defaulted arguments 936 break; 937 } 938 939 if (i) OS << ", "; 940 PrintExpr(Call->getArg(i)); 941 } 942 } 943 944 void StmtPrinter::VisitCallExpr(CallExpr *Call) { 945 PrintExpr(Call->getCallee()); 946 OS << "("; 947 PrintCallArgs(Call); 948 OS << ")"; 949 } 950 void StmtPrinter::VisitMemberExpr(MemberExpr *Node) { 951 // FIXME: Suppress printing implicit bases (like "this") 952 PrintExpr(Node->getBase()); 953 if (FieldDecl *FD = dyn_cast<FieldDecl>(Node->getMemberDecl())) 954 if (FD->isAnonymousStructOrUnion()) 955 return; 956 OS << (Node->isArrow() ? "->" : "."); 957 if (NestedNameSpecifier *Qualifier = Node->getQualifier()) 958 Qualifier->print(OS, Policy); 959 if (Node->hasTemplateKeyword()) 960 OS << "template "; 961 OS << Node->getMemberNameInfo(); 962 if (Node->hasExplicitTemplateArgs()) 963 OS << TemplateSpecializationType::PrintTemplateArgumentList( 964 Node->getTemplateArgs(), 965 Node->getNumTemplateArgs(), 966 Policy); 967 } 968 void StmtPrinter::VisitObjCIsaExpr(ObjCIsaExpr *Node) { 969 PrintExpr(Node->getBase()); 970 OS << (Node->isArrow() ? "->isa" : ".isa"); 971 } 972 973 void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) { 974 PrintExpr(Node->getBase()); 975 OS << "."; 976 OS << Node->getAccessor().getName(); 977 } 978 void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) { 979 OS << "(" << Node->getType().getAsString(Policy) << ")"; 980 PrintExpr(Node->getSubExpr()); 981 } 982 void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) { 983 OS << "(" << Node->getType().getAsString(Policy) << ")"; 984 PrintExpr(Node->getInitializer()); 985 } 986 void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) { 987 // No need to print anything, simply forward to the sub expression. 988 PrintExpr(Node->getSubExpr()); 989 } 990 void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) { 991 PrintExpr(Node->getLHS()); 992 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " "; 993 PrintExpr(Node->getRHS()); 994 } 995 void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) { 996 PrintExpr(Node->getLHS()); 997 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " "; 998 PrintExpr(Node->getRHS()); 999 } 1000 void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) { 1001 PrintExpr(Node->getCond()); 1002 OS << " ? "; 1003 PrintExpr(Node->getLHS()); 1004 OS << " : "; 1005 PrintExpr(Node->getRHS()); 1006 } 1007 1008 // GNU extensions. 1009 1010 void 1011 StmtPrinter::VisitBinaryConditionalOperator(BinaryConditionalOperator *Node) { 1012 PrintExpr(Node->getCommon()); 1013 OS << " ?: "; 1014 PrintExpr(Node->getFalseExpr()); 1015 } 1016 void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) { 1017 OS << "&&" << Node->getLabel()->getName(); 1018 } 1019 1020 void StmtPrinter::VisitStmtExpr(StmtExpr *E) { 1021 OS << "("; 1022 PrintRawCompoundStmt(E->getSubStmt()); 1023 OS << ")"; 1024 } 1025 1026 void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) { 1027 OS << "__builtin_choose_expr("; 1028 PrintExpr(Node->getCond()); 1029 OS << ", "; 1030 PrintExpr(Node->getLHS()); 1031 OS << ", "; 1032 PrintExpr(Node->getRHS()); 1033 OS << ")"; 1034 } 1035 1036 void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) { 1037 OS << "__null"; 1038 } 1039 1040 void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) { 1041 OS << "__builtin_shufflevector("; 1042 for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) { 1043 if (i) OS << ", "; 1044 PrintExpr(Node->getExpr(i)); 1045 } 1046 OS << ")"; 1047 } 1048 1049 void StmtPrinter::VisitInitListExpr(InitListExpr* Node) { 1050 if (Node->getSyntacticForm()) { 1051 Visit(Node->getSyntacticForm()); 1052 return; 1053 } 1054 1055 OS << "{ "; 1056 for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) { 1057 if (i) OS << ", "; 1058 if (Node->getInit(i)) 1059 PrintExpr(Node->getInit(i)); 1060 else 1061 OS << "0"; 1062 } 1063 OS << " }"; 1064 } 1065 1066 void StmtPrinter::VisitParenListExpr(ParenListExpr* Node) { 1067 OS << "( "; 1068 for (unsigned i = 0, e = Node->getNumExprs(); i != e; ++i) { 1069 if (i) OS << ", "; 1070 PrintExpr(Node->getExpr(i)); 1071 } 1072 OS << " )"; 1073 } 1074 1075 void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) { 1076 for (DesignatedInitExpr::designators_iterator D = Node->designators_begin(), 1077 DEnd = Node->designators_end(); 1078 D != DEnd; ++D) { 1079 if (D->isFieldDesignator()) { 1080 if (D->getDotLoc().isInvalid()) 1081 OS << D->getFieldName()->getName() << ":"; 1082 else 1083 OS << "." << D->getFieldName()->getName(); 1084 } else { 1085 OS << "["; 1086 if (D->isArrayDesignator()) { 1087 PrintExpr(Node->getArrayIndex(*D)); 1088 } else { 1089 PrintExpr(Node->getArrayRangeStart(*D)); 1090 OS << " ... "; 1091 PrintExpr(Node->getArrayRangeEnd(*D)); 1092 } 1093 OS << "]"; 1094 } 1095 } 1096 1097 OS << " = "; 1098 PrintExpr(Node->getInit()); 1099 } 1100 1101 void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) { 1102 if (Policy.LangOpts.CPlusPlus) 1103 OS << "/*implicit*/" << Node->getType().getAsString(Policy) << "()"; 1104 else { 1105 OS << "/*implicit*/(" << Node->getType().getAsString(Policy) << ")"; 1106 if (Node->getType()->isRecordType()) 1107 OS << "{}"; 1108 else 1109 OS << 0; 1110 } 1111 } 1112 1113 void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) { 1114 OS << "__builtin_va_arg("; 1115 PrintExpr(Node->getSubExpr()); 1116 OS << ", "; 1117 OS << Node->getType().getAsString(Policy); 1118 OS << ")"; 1119 } 1120 1121 void StmtPrinter::VisitPseudoObjectExpr(PseudoObjectExpr *Node) { 1122 PrintExpr(Node->getSyntacticForm()); 1123 } 1124 1125 void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) { 1126 const char *Name = 0; 1127 switch (Node->getOp()) { 1128 #define BUILTIN(ID, TYPE, ATTRS) 1129 #define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \ 1130 case AtomicExpr::AO ## ID: \ 1131 Name = #ID "("; \ 1132 break; 1133 #include "clang/Basic/Builtins.def" 1134 } 1135 OS << Name; 1136 1137 // AtomicExpr stores its subexpressions in a permuted order. 1138 PrintExpr(Node->getPtr()); 1139 OS << ", "; 1140 if (Node->getOp() != AtomicExpr::AO__c11_atomic_load && 1141 Node->getOp() != AtomicExpr::AO__atomic_load_n) { 1142 PrintExpr(Node->getVal1()); 1143 OS << ", "; 1144 } 1145 if (Node->getOp() == AtomicExpr::AO__atomic_exchange || 1146 Node->isCmpXChg()) { 1147 PrintExpr(Node->getVal2()); 1148 OS << ", "; 1149 } 1150 if (Node->getOp() == AtomicExpr::AO__atomic_compare_exchange || 1151 Node->getOp() == AtomicExpr::AO__atomic_compare_exchange_n) { 1152 PrintExpr(Node->getWeak()); 1153 OS << ", "; 1154 } 1155 if (Node->getOp() != AtomicExpr::AO__c11_atomic_init) 1156 PrintExpr(Node->getOrder()); 1157 if (Node->isCmpXChg()) { 1158 OS << ", "; 1159 PrintExpr(Node->getOrderFail()); 1160 } 1161 OS << ")"; 1162 } 1163 1164 // C++ 1165 void StmtPrinter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *Node) { 1166 const char *OpStrings[NUM_OVERLOADED_OPERATORS] = { 1167 "", 1168 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 1169 Spelling, 1170 #include "clang/Basic/OperatorKinds.def" 1171 }; 1172 1173 OverloadedOperatorKind Kind = Node->getOperator(); 1174 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) { 1175 if (Node->getNumArgs() == 1) { 1176 OS << OpStrings[Kind] << ' '; 1177 PrintExpr(Node->getArg(0)); 1178 } else { 1179 PrintExpr(Node->getArg(0)); 1180 OS << ' ' << OpStrings[Kind]; 1181 } 1182 } else if (Kind == OO_Call) { 1183 PrintExpr(Node->getArg(0)); 1184 OS << '('; 1185 for (unsigned ArgIdx = 1; ArgIdx < Node->getNumArgs(); ++ArgIdx) { 1186 if (ArgIdx > 1) 1187 OS << ", "; 1188 if (!isa<CXXDefaultArgExpr>(Node->getArg(ArgIdx))) 1189 PrintExpr(Node->getArg(ArgIdx)); 1190 } 1191 OS << ')'; 1192 } else if (Kind == OO_Subscript) { 1193 PrintExpr(Node->getArg(0)); 1194 OS << '['; 1195 PrintExpr(Node->getArg(1)); 1196 OS << ']'; 1197 } else if (Node->getNumArgs() == 1) { 1198 OS << OpStrings[Kind] << ' '; 1199 PrintExpr(Node->getArg(0)); 1200 } else if (Node->getNumArgs() == 2) { 1201 PrintExpr(Node->getArg(0)); 1202 OS << ' ' << OpStrings[Kind] << ' '; 1203 PrintExpr(Node->getArg(1)); 1204 } else { 1205 llvm_unreachable("unknown overloaded operator"); 1206 } 1207 } 1208 1209 void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) { 1210 VisitCallExpr(cast<CallExpr>(Node)); 1211 } 1212 1213 void StmtPrinter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *Node) { 1214 PrintExpr(Node->getCallee()); 1215 OS << "<<<"; 1216 PrintCallArgs(Node->getConfig()); 1217 OS << ">>>("; 1218 PrintCallArgs(Node); 1219 OS << ")"; 1220 } 1221 1222 void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) { 1223 OS << Node->getCastName() << '<'; 1224 OS << Node->getTypeAsWritten().getAsString(Policy) << ">("; 1225 PrintExpr(Node->getSubExpr()); 1226 OS << ")"; 1227 } 1228 1229 void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) { 1230 VisitCXXNamedCastExpr(Node); 1231 } 1232 1233 void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) { 1234 VisitCXXNamedCastExpr(Node); 1235 } 1236 1237 void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) { 1238 VisitCXXNamedCastExpr(Node); 1239 } 1240 1241 void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) { 1242 VisitCXXNamedCastExpr(Node); 1243 } 1244 1245 void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) { 1246 OS << "typeid("; 1247 if (Node->isTypeOperand()) { 1248 OS << Node->getTypeOperand().getAsString(Policy); 1249 } else { 1250 PrintExpr(Node->getExprOperand()); 1251 } 1252 OS << ")"; 1253 } 1254 1255 void StmtPrinter::VisitCXXUuidofExpr(CXXUuidofExpr *Node) { 1256 OS << "__uuidof("; 1257 if (Node->isTypeOperand()) { 1258 OS << Node->getTypeOperand().getAsString(Policy); 1259 } else { 1260 PrintExpr(Node->getExprOperand()); 1261 } 1262 OS << ")"; 1263 } 1264 1265 void StmtPrinter::VisitUserDefinedLiteral(UserDefinedLiteral *Node) { 1266 switch (Node->getLiteralOperatorKind()) { 1267 case UserDefinedLiteral::LOK_Raw: 1268 OS << cast<StringLiteral>(Node->getArg(0)->IgnoreImpCasts())->getString(); 1269 break; 1270 case UserDefinedLiteral::LOK_Template: { 1271 DeclRefExpr *DRE = cast<DeclRefExpr>(Node->getCallee()->IgnoreImpCasts()); 1272 const TemplateArgumentList *Args = 1273 cast<FunctionDecl>(DRE->getDecl())->getTemplateSpecializationArgs(); 1274 assert(Args); 1275 const TemplateArgument &Pack = Args->get(0); 1276 for (TemplateArgument::pack_iterator I = Pack.pack_begin(), 1277 E = Pack.pack_end(); I != E; ++I) { 1278 char C = (char)I->getAsIntegral()->getZExtValue(); 1279 OS << C; 1280 } 1281 break; 1282 } 1283 case UserDefinedLiteral::LOK_Integer: { 1284 // Print integer literal without suffix. 1285 IntegerLiteral *Int = cast<IntegerLiteral>(Node->getCookedLiteral()); 1286 OS << Int->getValue().toString(10, /*isSigned*/false); 1287 break; 1288 } 1289 case UserDefinedLiteral::LOK_Floating: 1290 case UserDefinedLiteral::LOK_String: 1291 case UserDefinedLiteral::LOK_Character: 1292 PrintExpr(Node->getCookedLiteral()); 1293 break; 1294 } 1295 OS << Node->getUDSuffix()->getName(); 1296 } 1297 1298 void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) { 1299 OS << (Node->getValue() ? "true" : "false"); 1300 } 1301 1302 void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) { 1303 OS << "nullptr"; 1304 } 1305 1306 void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) { 1307 OS << "this"; 1308 } 1309 1310 void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) { 1311 if (Node->getSubExpr() == 0) 1312 OS << "throw"; 1313 else { 1314 OS << "throw "; 1315 PrintExpr(Node->getSubExpr()); 1316 } 1317 } 1318 1319 void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) { 1320 // Nothing to print: we picked up the default argument 1321 } 1322 1323 void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) { 1324 OS << Node->getType().getAsString(Policy); 1325 OS << "("; 1326 PrintExpr(Node->getSubExpr()); 1327 OS << ")"; 1328 } 1329 1330 void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) { 1331 PrintExpr(Node->getSubExpr()); 1332 } 1333 1334 void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) { 1335 OS << Node->getType().getAsString(Policy); 1336 OS << "("; 1337 for (CXXTemporaryObjectExpr::arg_iterator Arg = Node->arg_begin(), 1338 ArgEnd = Node->arg_end(); 1339 Arg != ArgEnd; ++Arg) { 1340 if (Arg != Node->arg_begin()) 1341 OS << ", "; 1342 PrintExpr(*Arg); 1343 } 1344 OS << ")"; 1345 } 1346 1347 void StmtPrinter::VisitLambdaExpr(LambdaExpr *Node) { 1348 OS << '['; 1349 bool NeedComma = false; 1350 switch (Node->getCaptureDefault()) { 1351 case LCD_None: 1352 break; 1353 1354 case LCD_ByCopy: 1355 OS << '='; 1356 NeedComma = true; 1357 break; 1358 1359 case LCD_ByRef: 1360 OS << '&'; 1361 NeedComma = true; 1362 break; 1363 } 1364 for (LambdaExpr::capture_iterator C = Node->explicit_capture_begin(), 1365 CEnd = Node->explicit_capture_end(); 1366 C != CEnd; 1367 ++C) { 1368 if (NeedComma) 1369 OS << ", "; 1370 NeedComma = true; 1371 1372 switch (C->getCaptureKind()) { 1373 case LCK_This: 1374 OS << "this"; 1375 break; 1376 1377 case LCK_ByRef: 1378 if (Node->getCaptureDefault() != LCD_ByRef) 1379 OS << '&'; 1380 OS << C->getCapturedVar()->getName(); 1381 break; 1382 1383 case LCK_ByCopy: 1384 if (Node->getCaptureDefault() != LCD_ByCopy) 1385 OS << '='; 1386 OS << C->getCapturedVar()->getName(); 1387 break; 1388 } 1389 } 1390 OS << ']'; 1391 1392 if (Node->hasExplicitParameters()) { 1393 OS << " ("; 1394 CXXMethodDecl *Method = Node->getCallOperator(); 1395 NeedComma = false; 1396 for (CXXMethodDecl::param_iterator P = Method->param_begin(), 1397 PEnd = Method->param_end(); 1398 P != PEnd; ++P) { 1399 if (NeedComma) { 1400 OS << ", "; 1401 } else { 1402 NeedComma = true; 1403 } 1404 std::string ParamStr = (*P)->getNameAsString(); 1405 (*P)->getOriginalType().getAsStringInternal(ParamStr, Policy); 1406 OS << ParamStr; 1407 } 1408 if (Method->isVariadic()) { 1409 if (NeedComma) 1410 OS << ", "; 1411 OS << "..."; 1412 } 1413 OS << ')'; 1414 1415 if (Node->isMutable()) 1416 OS << " mutable"; 1417 1418 const FunctionProtoType *Proto 1419 = Method->getType()->getAs<FunctionProtoType>(); 1420 { 1421 std::string ExceptionSpec; 1422 Proto->printExceptionSpecification(ExceptionSpec, Policy); 1423 OS << ExceptionSpec; 1424 } 1425 1426 // FIXME: Attributes 1427 1428 // Print the trailing return type if it was specified in the source. 1429 if (Node->hasExplicitResultType()) 1430 OS << " -> " << Proto->getResultType().getAsString(Policy); 1431 } 1432 1433 // Print the body. 1434 CompoundStmt *Body = Node->getBody(); 1435 OS << ' '; 1436 PrintStmt(Body); 1437 } 1438 1439 void StmtPrinter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *Node) { 1440 if (TypeSourceInfo *TSInfo = Node->getTypeSourceInfo()) 1441 OS << TSInfo->getType().getAsString(Policy) << "()"; 1442 else 1443 OS << Node->getType().getAsString(Policy) << "()"; 1444 } 1445 1446 void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) { 1447 if (E->isGlobalNew()) 1448 OS << "::"; 1449 OS << "new "; 1450 unsigned NumPlace = E->getNumPlacementArgs(); 1451 if (NumPlace > 0) { 1452 OS << "("; 1453 PrintExpr(E->getPlacementArg(0)); 1454 for (unsigned i = 1; i < NumPlace; ++i) { 1455 OS << ", "; 1456 PrintExpr(E->getPlacementArg(i)); 1457 } 1458 OS << ") "; 1459 } 1460 if (E->isParenTypeId()) 1461 OS << "("; 1462 std::string TypeS; 1463 if (Expr *Size = E->getArraySize()) { 1464 llvm::raw_string_ostream s(TypeS); 1465 Size->printPretty(s, Context, Helper, Policy); 1466 s.flush(); 1467 TypeS = "[" + TypeS + "]"; 1468 } 1469 E->getAllocatedType().getAsStringInternal(TypeS, Policy); 1470 OS << TypeS; 1471 if (E->isParenTypeId()) 1472 OS << ")"; 1473 1474 CXXNewExpr::InitializationStyle InitStyle = E->getInitializationStyle(); 1475 if (InitStyle) { 1476 if (InitStyle == CXXNewExpr::CallInit) 1477 OS << "("; 1478 PrintExpr(E->getInitializer()); 1479 if (InitStyle == CXXNewExpr::CallInit) 1480 OS << ")"; 1481 } 1482 } 1483 1484 void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 1485 if (E->isGlobalDelete()) 1486 OS << "::"; 1487 OS << "delete "; 1488 if (E->isArrayForm()) 1489 OS << "[] "; 1490 PrintExpr(E->getArgument()); 1491 } 1492 1493 void StmtPrinter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 1494 PrintExpr(E->getBase()); 1495 if (E->isArrow()) 1496 OS << "->"; 1497 else 1498 OS << '.'; 1499 if (E->getQualifier()) 1500 E->getQualifier()->print(OS, Policy); 1501 1502 std::string TypeS; 1503 if (IdentifierInfo *II = E->getDestroyedTypeIdentifier()) 1504 OS << II->getName(); 1505 else 1506 E->getDestroyedType().getAsStringInternal(TypeS, Policy); 1507 OS << TypeS; 1508 } 1509 1510 void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) { 1511 for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) { 1512 if (isa<CXXDefaultArgExpr>(E->getArg(i))) { 1513 // Don't print any defaulted arguments 1514 break; 1515 } 1516 1517 if (i) OS << ", "; 1518 PrintExpr(E->getArg(i)); 1519 } 1520 } 1521 1522 void StmtPrinter::VisitExprWithCleanups(ExprWithCleanups *E) { 1523 // Just forward to the sub expression. 1524 PrintExpr(E->getSubExpr()); 1525 } 1526 1527 void 1528 StmtPrinter::VisitCXXUnresolvedConstructExpr( 1529 CXXUnresolvedConstructExpr *Node) { 1530 OS << Node->getTypeAsWritten().getAsString(Policy); 1531 OS << "("; 1532 for (CXXUnresolvedConstructExpr::arg_iterator Arg = Node->arg_begin(), 1533 ArgEnd = Node->arg_end(); 1534 Arg != ArgEnd; ++Arg) { 1535 if (Arg != Node->arg_begin()) 1536 OS << ", "; 1537 PrintExpr(*Arg); 1538 } 1539 OS << ")"; 1540 } 1541 1542 void StmtPrinter::VisitCXXDependentScopeMemberExpr( 1543 CXXDependentScopeMemberExpr *Node) { 1544 if (!Node->isImplicitAccess()) { 1545 PrintExpr(Node->getBase()); 1546 OS << (Node->isArrow() ? "->" : "."); 1547 } 1548 if (NestedNameSpecifier *Qualifier = Node->getQualifier()) 1549 Qualifier->print(OS, Policy); 1550 if (Node->hasTemplateKeyword()) 1551 OS << "template "; 1552 OS << Node->getMemberNameInfo(); 1553 if (Node->hasExplicitTemplateArgs()) { 1554 OS << TemplateSpecializationType::PrintTemplateArgumentList( 1555 Node->getTemplateArgs(), 1556 Node->getNumTemplateArgs(), 1557 Policy); 1558 } 1559 } 1560 1561 void StmtPrinter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *Node) { 1562 if (!Node->isImplicitAccess()) { 1563 PrintExpr(Node->getBase()); 1564 OS << (Node->isArrow() ? "->" : "."); 1565 } 1566 if (NestedNameSpecifier *Qualifier = Node->getQualifier()) 1567 Qualifier->print(OS, Policy); 1568 if (Node->hasTemplateKeyword()) 1569 OS << "template "; 1570 OS << Node->getMemberNameInfo(); 1571 if (Node->hasExplicitTemplateArgs()) { 1572 OS << TemplateSpecializationType::PrintTemplateArgumentList( 1573 Node->getTemplateArgs(), 1574 Node->getNumTemplateArgs(), 1575 Policy); 1576 } 1577 } 1578 1579 static const char *getTypeTraitName(UnaryTypeTrait UTT) { 1580 switch (UTT) { 1581 case UTT_HasNothrowAssign: return "__has_nothrow_assign"; 1582 case UTT_HasNothrowConstructor: return "__has_nothrow_constructor"; 1583 case UTT_HasNothrowCopy: return "__has_nothrow_copy"; 1584 case UTT_HasTrivialAssign: return "__has_trivial_assign"; 1585 case UTT_HasTrivialDefaultConstructor: return "__has_trivial_constructor"; 1586 case UTT_HasTrivialCopy: return "__has_trivial_copy"; 1587 case UTT_HasTrivialDestructor: return "__has_trivial_destructor"; 1588 case UTT_HasVirtualDestructor: return "__has_virtual_destructor"; 1589 case UTT_IsAbstract: return "__is_abstract"; 1590 case UTT_IsArithmetic: return "__is_arithmetic"; 1591 case UTT_IsArray: return "__is_array"; 1592 case UTT_IsClass: return "__is_class"; 1593 case UTT_IsCompleteType: return "__is_complete_type"; 1594 case UTT_IsCompound: return "__is_compound"; 1595 case UTT_IsConst: return "__is_const"; 1596 case UTT_IsEmpty: return "__is_empty"; 1597 case UTT_IsEnum: return "__is_enum"; 1598 case UTT_IsFinal: return "__is_final"; 1599 case UTT_IsFloatingPoint: return "__is_floating_point"; 1600 case UTT_IsFunction: return "__is_function"; 1601 case UTT_IsFundamental: return "__is_fundamental"; 1602 case UTT_IsIntegral: return "__is_integral"; 1603 case UTT_IsLiteral: return "__is_literal"; 1604 case UTT_IsLvalueReference: return "__is_lvalue_reference"; 1605 case UTT_IsMemberFunctionPointer: return "__is_member_function_pointer"; 1606 case UTT_IsMemberObjectPointer: return "__is_member_object_pointer"; 1607 case UTT_IsMemberPointer: return "__is_member_pointer"; 1608 case UTT_IsObject: return "__is_object"; 1609 case UTT_IsPOD: return "__is_pod"; 1610 case UTT_IsPointer: return "__is_pointer"; 1611 case UTT_IsPolymorphic: return "__is_polymorphic"; 1612 case UTT_IsReference: return "__is_reference"; 1613 case UTT_IsRvalueReference: return "__is_rvalue_reference"; 1614 case UTT_IsScalar: return "__is_scalar"; 1615 case UTT_IsSigned: return "__is_signed"; 1616 case UTT_IsStandardLayout: return "__is_standard_layout"; 1617 case UTT_IsTrivial: return "__is_trivial"; 1618 case UTT_IsTriviallyCopyable: return "__is_trivially_copyable"; 1619 case UTT_IsUnion: return "__is_union"; 1620 case UTT_IsUnsigned: return "__is_unsigned"; 1621 case UTT_IsVoid: return "__is_void"; 1622 case UTT_IsVolatile: return "__is_volatile"; 1623 } 1624 llvm_unreachable("Type trait not covered by switch statement"); 1625 } 1626 1627 static const char *getTypeTraitName(BinaryTypeTrait BTT) { 1628 switch (BTT) { 1629 case BTT_IsBaseOf: return "__is_base_of"; 1630 case BTT_IsConvertible: return "__is_convertible"; 1631 case BTT_IsSame: return "__is_same"; 1632 case BTT_TypeCompatible: return "__builtin_types_compatible_p"; 1633 case BTT_IsConvertibleTo: return "__is_convertible_to"; 1634 case BTT_IsTriviallyAssignable: return "__is_trivially_assignable"; 1635 } 1636 llvm_unreachable("Binary type trait not covered by switch"); 1637 } 1638 1639 static const char *getTypeTraitName(TypeTrait TT) { 1640 switch (TT) { 1641 case clang::TT_IsTriviallyConstructible:return "__is_trivially_constructible"; 1642 } 1643 llvm_unreachable("Type trait not covered by switch"); 1644 } 1645 1646 static const char *getTypeTraitName(ArrayTypeTrait ATT) { 1647 switch (ATT) { 1648 case ATT_ArrayRank: return "__array_rank"; 1649 case ATT_ArrayExtent: return "__array_extent"; 1650 } 1651 llvm_unreachable("Array type trait not covered by switch"); 1652 } 1653 1654 static const char *getExpressionTraitName(ExpressionTrait ET) { 1655 switch (ET) { 1656 case ET_IsLValueExpr: return "__is_lvalue_expr"; 1657 case ET_IsRValueExpr: return "__is_rvalue_expr"; 1658 } 1659 llvm_unreachable("Expression type trait not covered by switch"); 1660 } 1661 1662 void StmtPrinter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 1663 OS << getTypeTraitName(E->getTrait()) << "(" 1664 << E->getQueriedType().getAsString(Policy) << ")"; 1665 } 1666 1667 void StmtPrinter::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) { 1668 OS << getTypeTraitName(E->getTrait()) << "(" 1669 << E->getLhsType().getAsString(Policy) << "," 1670 << E->getRhsType().getAsString(Policy) << ")"; 1671 } 1672 1673 void StmtPrinter::VisitTypeTraitExpr(TypeTraitExpr *E) { 1674 OS << getTypeTraitName(E->getTrait()) << "("; 1675 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 1676 if (I > 0) 1677 OS << ", "; 1678 OS << E->getArg(I)->getType().getAsString(Policy); 1679 } 1680 OS << ")"; 1681 } 1682 1683 void StmtPrinter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 1684 OS << getTypeTraitName(E->getTrait()) << "(" 1685 << E->getQueriedType().getAsString(Policy) << ")"; 1686 } 1687 1688 void StmtPrinter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 1689 OS << getExpressionTraitName(E->getTrait()) << "("; 1690 PrintExpr(E->getQueriedExpression()); 1691 OS << ")"; 1692 } 1693 1694 void StmtPrinter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 1695 OS << "noexcept("; 1696 PrintExpr(E->getOperand()); 1697 OS << ")"; 1698 } 1699 1700 void StmtPrinter::VisitPackExpansionExpr(PackExpansionExpr *E) { 1701 PrintExpr(E->getPattern()); 1702 OS << "..."; 1703 } 1704 1705 void StmtPrinter::VisitSizeOfPackExpr(SizeOfPackExpr *E) { 1706 OS << "sizeof...(" << *E->getPack() << ")"; 1707 } 1708 1709 void StmtPrinter::VisitSubstNonTypeTemplateParmPackExpr( 1710 SubstNonTypeTemplateParmPackExpr *Node) { 1711 OS << *Node->getParameterPack(); 1712 } 1713 1714 void StmtPrinter::VisitSubstNonTypeTemplateParmExpr( 1715 SubstNonTypeTemplateParmExpr *Node) { 1716 Visit(Node->getReplacement()); 1717 } 1718 1719 void StmtPrinter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *Node){ 1720 PrintExpr(Node->GetTemporaryExpr()); 1721 } 1722 1723 // Obj-C 1724 1725 void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) { 1726 OS << "@"; 1727 VisitStringLiteral(Node->getString()); 1728 } 1729 1730 void StmtPrinter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) { 1731 OS << "@"; 1732 Visit(E->getSubExpr()); 1733 } 1734 1735 void StmtPrinter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) { 1736 OS << "@[ "; 1737 StmtRange ch = E->children(); 1738 if (ch.first != ch.second) { 1739 while (1) { 1740 Visit(*ch.first); 1741 ++ch.first; 1742 if (ch.first == ch.second) break; 1743 OS << ", "; 1744 } 1745 } 1746 OS << " ]"; 1747 } 1748 1749 void StmtPrinter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { 1750 OS << "@{ "; 1751 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) { 1752 if (I > 0) 1753 OS << ", "; 1754 1755 ObjCDictionaryElement Element = E->getKeyValueElement(I); 1756 Visit(Element.Key); 1757 OS << " : "; 1758 Visit(Element.Value); 1759 if (Element.isPackExpansion()) 1760 OS << "..."; 1761 } 1762 OS << " }"; 1763 } 1764 1765 void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) { 1766 OS << "@encode(" << Node->getEncodedType().getAsString(Policy) << ')'; 1767 } 1768 1769 void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) { 1770 OS << "@selector(" << Node->getSelector().getAsString() << ')'; 1771 } 1772 1773 void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) { 1774 OS << "@protocol(" << *Node->getProtocol() << ')'; 1775 } 1776 1777 void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) { 1778 OS << "["; 1779 switch (Mess->getReceiverKind()) { 1780 case ObjCMessageExpr::Instance: 1781 PrintExpr(Mess->getInstanceReceiver()); 1782 break; 1783 1784 case ObjCMessageExpr::Class: 1785 OS << Mess->getClassReceiver().getAsString(Policy); 1786 break; 1787 1788 case ObjCMessageExpr::SuperInstance: 1789 case ObjCMessageExpr::SuperClass: 1790 OS << "Super"; 1791 break; 1792 } 1793 1794 OS << ' '; 1795 Selector selector = Mess->getSelector(); 1796 if (selector.isUnarySelector()) { 1797 OS << selector.getNameForSlot(0); 1798 } else { 1799 for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) { 1800 if (i < selector.getNumArgs()) { 1801 if (i > 0) OS << ' '; 1802 if (selector.getIdentifierInfoForSlot(i)) 1803 OS << selector.getIdentifierInfoForSlot(i)->getName() << ':'; 1804 else 1805 OS << ":"; 1806 } 1807 else OS << ", "; // Handle variadic methods. 1808 1809 PrintExpr(Mess->getArg(i)); 1810 } 1811 } 1812 OS << "]"; 1813 } 1814 1815 void StmtPrinter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Node) { 1816 OS << (Node->getValue() ? "__objc_yes" : "__objc_no"); 1817 } 1818 1819 void 1820 StmtPrinter::VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { 1821 PrintExpr(E->getSubExpr()); 1822 } 1823 1824 void 1825 StmtPrinter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { 1826 OS << "(" << E->getBridgeKindName() << E->getType().getAsString(Policy) 1827 << ")"; 1828 PrintExpr(E->getSubExpr()); 1829 } 1830 1831 void StmtPrinter::VisitBlockExpr(BlockExpr *Node) { 1832 BlockDecl *BD = Node->getBlockDecl(); 1833 OS << "^"; 1834 1835 const FunctionType *AFT = Node->getFunctionType(); 1836 1837 if (isa<FunctionNoProtoType>(AFT)) { 1838 OS << "()"; 1839 } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) { 1840 OS << '('; 1841 std::string ParamStr; 1842 for (BlockDecl::param_iterator AI = BD->param_begin(), 1843 E = BD->param_end(); AI != E; ++AI) { 1844 if (AI != BD->param_begin()) OS << ", "; 1845 ParamStr = (*AI)->getNameAsString(); 1846 (*AI)->getType().getAsStringInternal(ParamStr, Policy); 1847 OS << ParamStr; 1848 } 1849 1850 const FunctionProtoType *FT = cast<FunctionProtoType>(AFT); 1851 if (FT->isVariadic()) { 1852 if (!BD->param_empty()) OS << ", "; 1853 OS << "..."; 1854 } 1855 OS << ')'; 1856 } 1857 } 1858 1859 void StmtPrinter::VisitOpaqueValueExpr(OpaqueValueExpr *Node) { 1860 PrintExpr(Node->getSourceExpr()); 1861 } 1862 1863 void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) { 1864 OS << "__builtin_astype("; 1865 PrintExpr(Node->getSrcExpr()); 1866 OS << ", " << Node->getType().getAsString(); 1867 OS << ")"; 1868 } 1869 1870 //===----------------------------------------------------------------------===// 1871 // Stmt method implementations 1872 //===----------------------------------------------------------------------===// 1873 1874 void Stmt::dumpPretty(ASTContext& Context) const { 1875 printPretty(llvm::errs(), Context, 0, 1876 PrintingPolicy(Context.getLangOpts())); 1877 } 1878 1879 void Stmt::printPretty(raw_ostream &OS, ASTContext& Context, 1880 PrinterHelper* Helper, 1881 const PrintingPolicy &Policy, 1882 unsigned Indentation) const { 1883 if (this == 0) { 1884 OS << "<NULL>"; 1885 return; 1886 } 1887 1888 if (Policy.Dump && &Context) { 1889 dump(OS, Context.getSourceManager()); 1890 return; 1891 } 1892 1893 StmtPrinter P(OS, Context, Helper, Policy, Indentation); 1894 P.Visit(const_cast<Stmt*>(this)); 1895 } 1896 1897 //===----------------------------------------------------------------------===// 1898 // PrinterHelper 1899 //===----------------------------------------------------------------------===// 1900 1901 // Implement virtual destructor. 1902 PrinterHelper::~PrinterHelper() {} 1903
