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