1 //===--- StmtPrinter.cpp - Printing implementation for Stmt ASTs ----------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Stmt::dumpPretty/Stmt::printPretty methods, which
11 // pretty print the AST back out to C code.
13 //===----------------------------------------------------------------------===//
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/StmtVisitor.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/PrettyPrinter.h"
21 #include "clang/AST/Expr.h"
22 #include "clang/AST/ExprCXX.h"
23 #include "llvm/ADT/SmallString.h"
24 using namespace clang;
26 //===----------------------------------------------------------------------===//
27 // StmtPrinter Visitor
28 //===----------------------------------------------------------------------===//
31 class StmtPrinter : public StmtVisitor<StmtPrinter> {
34 clang::PrinterHelper* Helper;
35 PrintingPolicy Policy;
38 StmtPrinter(raw_ostream &os, PrinterHelper* helper,
39 const PrintingPolicy &Policy,
40 unsigned Indentation = 0)
41 : OS(os), IndentLevel(Indentation), Helper(helper), Policy(Policy) {}
43 void PrintStmt(Stmt *S) {
44 PrintStmt(S, Policy.Indentation);
47 void PrintStmt(Stmt *S, int SubIndent) {
48 IndentLevel += SubIndent;
49 if (S && isa<Expr>(S)) {
50 // If this is an expr used in a stmt context, indent and newline it.
57 Indent() << "<<<NULL STATEMENT>>>\n";
59 IndentLevel -= SubIndent;
62 void PrintRawCompoundStmt(CompoundStmt *S);
63 void PrintRawDecl(Decl *D);
64 void PrintRawDeclStmt(const DeclStmt *S);
65 void PrintRawIfStmt(IfStmt *If);
66 void PrintRawCXXCatchStmt(CXXCatchStmt *Catch);
67 void PrintCallArgs(CallExpr *E);
68 void PrintRawSEHExceptHandler(SEHExceptStmt *S);
69 void PrintRawSEHFinallyStmt(SEHFinallyStmt *S);
71 void PrintExpr(Expr *E) {
78 raw_ostream &Indent(int Delta = 0) {
79 for (int i = 0, e = IndentLevel+Delta; i < e; ++i)
85 if (Helper && Helper->handledStmt(S,OS))
87 else StmtVisitor<StmtPrinter>::Visit(S);
90 void VisitStmt(Stmt *Node) LLVM_ATTRIBUTE_UNUSED {
91 Indent() << "<<unknown stmt type>>\n";
93 void VisitExpr(Expr *Node) LLVM_ATTRIBUTE_UNUSED {
94 OS << "<<unknown expr type>>";
96 void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
98 #define ABSTRACT_STMT(CLASS)
99 #define STMT(CLASS, PARENT) \
100 void Visit##CLASS(CLASS *Node);
101 #include "clang/AST/StmtNodes.inc"
105 //===----------------------------------------------------------------------===//
106 // Stmt printing methods.
107 //===----------------------------------------------------------------------===//
109 /// PrintRawCompoundStmt - Print a compound stmt without indenting the {, and
110 /// with no newline after the }.
111 void StmtPrinter::PrintRawCompoundStmt(CompoundStmt *Node) {
113 for (CompoundStmt::body_iterator I = Node->body_begin(), E = Node->body_end();
120 void StmtPrinter::PrintRawDecl(Decl *D) {
121 D->print(OS, Policy, IndentLevel);
124 void StmtPrinter::PrintRawDeclStmt(const DeclStmt *S) {
125 DeclStmt::const_decl_iterator Begin = S->decl_begin(), End = S->decl_end();
126 SmallVector<Decl*, 2> Decls;
127 for ( ; Begin != End; ++Begin)
128 Decls.push_back(*Begin);
130 Decl::printGroup(Decls.data(), Decls.size(), OS, Policy, IndentLevel);
133 void StmtPrinter::VisitNullStmt(NullStmt *Node) {
137 void StmtPrinter::VisitDeclStmt(DeclStmt *Node) {
139 PrintRawDeclStmt(Node);
143 void StmtPrinter::VisitCompoundStmt(CompoundStmt *Node) {
145 PrintRawCompoundStmt(Node);
149 void StmtPrinter::VisitCaseStmt(CaseStmt *Node) {
150 Indent(-1) << "case ";
151 PrintExpr(Node->getLHS());
152 if (Node->getRHS()) {
154 PrintExpr(Node->getRHS());
158 PrintStmt(Node->getSubStmt(), 0);
161 void StmtPrinter::VisitDefaultStmt(DefaultStmt *Node) {
162 Indent(-1) << "default:\n";
163 PrintStmt(Node->getSubStmt(), 0);
166 void StmtPrinter::VisitLabelStmt(LabelStmt *Node) {
167 Indent(-1) << Node->getName() << ":\n";
168 PrintStmt(Node->getSubStmt(), 0);
171 void StmtPrinter::VisitAttributedStmt(AttributedStmt *Node) {
174 for (ArrayRef<const Attr*>::iterator it = Node->getAttrs().begin(),
175 end = Node->getAttrs().end();
182 (*it)->printPretty(OS, Policy);
185 PrintStmt(Node->getSubStmt(), 0);
188 void StmtPrinter::PrintRawIfStmt(IfStmt *If) {
190 if (const DeclStmt *DS = If->getConditionVariableDeclStmt())
191 PrintRawDeclStmt(DS);
193 PrintExpr(If->getCond());
196 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(If->getThen())) {
198 PrintRawCompoundStmt(CS);
199 OS << (If->getElse() ? ' ' : '\n');
202 PrintStmt(If->getThen());
203 if (If->getElse()) Indent();
206 if (Stmt *Else = If->getElse()) {
209 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Else)) {
211 PrintRawCompoundStmt(CS);
213 } else if (IfStmt *ElseIf = dyn_cast<IfStmt>(Else)) {
215 PrintRawIfStmt(ElseIf);
218 PrintStmt(If->getElse());
223 void StmtPrinter::VisitIfStmt(IfStmt *If) {
228 void StmtPrinter::VisitSwitchStmt(SwitchStmt *Node) {
229 Indent() << "switch (";
230 if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
231 PrintRawDeclStmt(DS);
233 PrintExpr(Node->getCond());
236 // Pretty print compoundstmt bodies (very common).
237 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
239 PrintRawCompoundStmt(CS);
243 PrintStmt(Node->getBody());
247 void StmtPrinter::VisitWhileStmt(WhileStmt *Node) {
248 Indent() << "while (";
249 if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
250 PrintRawDeclStmt(DS);
252 PrintExpr(Node->getCond());
254 PrintStmt(Node->getBody());
257 void StmtPrinter::VisitDoStmt(DoStmt *Node) {
259 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
260 PrintRawCompoundStmt(CS);
264 PrintStmt(Node->getBody());
269 PrintExpr(Node->getCond());
273 void StmtPrinter::VisitForStmt(ForStmt *Node) {
275 if (Node->getInit()) {
276 if (DeclStmt *DS = dyn_cast<DeclStmt>(Node->getInit()))
277 PrintRawDeclStmt(DS);
279 PrintExpr(cast<Expr>(Node->getInit()));
282 if (Node->getCond()) {
284 PrintExpr(Node->getCond());
287 if (Node->getInc()) {
289 PrintExpr(Node->getInc());
293 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
294 PrintRawCompoundStmt(CS);
298 PrintStmt(Node->getBody());
302 void StmtPrinter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *Node) {
304 if (DeclStmt *DS = dyn_cast<DeclStmt>(Node->getElement()))
305 PrintRawDeclStmt(DS);
307 PrintExpr(cast<Expr>(Node->getElement()));
309 PrintExpr(Node->getCollection());
312 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
313 PrintRawCompoundStmt(CS);
317 PrintStmt(Node->getBody());
321 void StmtPrinter::VisitCXXForRangeStmt(CXXForRangeStmt *Node) {
323 PrintingPolicy SubPolicy(Policy);
324 SubPolicy.SuppressInitializers = true;
325 Node->getLoopVariable()->print(OS, SubPolicy, IndentLevel);
327 PrintExpr(Node->getRangeInit());
329 PrintStmt(Node->getBody());
333 void StmtPrinter::VisitMSDependentExistsStmt(MSDependentExistsStmt *Node) {
335 if (Node->isIfExists())
336 OS << "__if_exists (";
338 OS << "__if_not_exists (";
340 if (NestedNameSpecifier *Qualifier
341 = Node->getQualifierLoc().getNestedNameSpecifier())
342 Qualifier->print(OS, Policy);
344 OS << Node->getNameInfo() << ") ";
346 PrintRawCompoundStmt(Node->getSubStmt());
349 void StmtPrinter::VisitGotoStmt(GotoStmt *Node) {
350 Indent() << "goto " << Node->getLabel()->getName() << ";\n";
353 void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) {
354 Indent() << "goto *";
355 PrintExpr(Node->getTarget());
359 void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) {
360 Indent() << "continue;\n";
363 void StmtPrinter::VisitBreakStmt(BreakStmt *Node) {
364 Indent() << "break;\n";
368 void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) {
369 Indent() << "return";
370 if (Node->getRetValue()) {
372 PrintExpr(Node->getRetValue());
378 void StmtPrinter::VisitGCCAsmStmt(GCCAsmStmt *Node) {
381 if (Node->isVolatile())
385 VisitStringLiteral(Node->getAsmString());
388 if (Node->getNumOutputs() != 0 || Node->getNumInputs() != 0 ||
389 Node->getNumClobbers() != 0)
392 for (unsigned i = 0, e = Node->getNumOutputs(); i != e; ++i) {
396 if (!Node->getOutputName(i).empty()) {
398 OS << Node->getOutputName(i);
402 VisitStringLiteral(Node->getOutputConstraintLiteral(i));
404 Visit(Node->getOutputExpr(i));
408 if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0)
411 for (unsigned i = 0, e = Node->getNumInputs(); i != e; ++i) {
415 if (!Node->getInputName(i).empty()) {
417 OS << Node->getInputName(i);
421 VisitStringLiteral(Node->getInputConstraintLiteral(i));
423 Visit(Node->getInputExpr(i));
427 if (Node->getNumClobbers() != 0)
430 for (unsigned i = 0, e = Node->getNumClobbers(); i != e; ++i) {
434 VisitStringLiteral(Node->getClobberStringLiteral(i));
440 void StmtPrinter::VisitMSAsmStmt(MSAsmStmt *Node) {
441 // FIXME: Implement MS style inline asm statement printer.
442 Indent() << "__asm ";
443 if (Node->hasBraces())
445 OS << *(Node->getAsmString()) << "\n";
446 if (Node->hasBraces())
450 void StmtPrinter::VisitObjCAtTryStmt(ObjCAtTryStmt *Node) {
452 if (CompoundStmt *TS = dyn_cast<CompoundStmt>(Node->getTryBody())) {
453 PrintRawCompoundStmt(TS);
457 for (unsigned I = 0, N = Node->getNumCatchStmts(); I != N; ++I) {
458 ObjCAtCatchStmt *catchStmt = Node->getCatchStmt(I);
459 Indent() << "@catch(";
460 if (catchStmt->getCatchParamDecl()) {
461 if (Decl *DS = catchStmt->getCatchParamDecl())
465 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(catchStmt->getCatchBody())) {
466 PrintRawCompoundStmt(CS);
471 if (ObjCAtFinallyStmt *FS = static_cast<ObjCAtFinallyStmt *>(
472 Node->getFinallyStmt())) {
473 Indent() << "@finally";
474 PrintRawCompoundStmt(dyn_cast<CompoundStmt>(FS->getFinallyBody()));
479 void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) {
482 void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) {
483 Indent() << "@catch (...) { /* todo */ } \n";
486 void StmtPrinter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *Node) {
487 Indent() << "@throw";
488 if (Node->getThrowExpr()) {
490 PrintExpr(Node->getThrowExpr());
495 void StmtPrinter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *Node) {
496 Indent() << "@synchronized (";
497 PrintExpr(Node->getSynchExpr());
499 PrintRawCompoundStmt(Node->getSynchBody());
503 void StmtPrinter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *Node) {
504 Indent() << "@autoreleasepool";
505 PrintRawCompoundStmt(dyn_cast<CompoundStmt>(Node->getSubStmt()));
509 void StmtPrinter::PrintRawCXXCatchStmt(CXXCatchStmt *Node) {
511 if (Decl *ExDecl = Node->getExceptionDecl())
512 PrintRawDecl(ExDecl);
516 PrintRawCompoundStmt(cast<CompoundStmt>(Node->getHandlerBlock()));
519 void StmtPrinter::VisitCXXCatchStmt(CXXCatchStmt *Node) {
521 PrintRawCXXCatchStmt(Node);
525 void StmtPrinter::VisitCXXTryStmt(CXXTryStmt *Node) {
527 PrintRawCompoundStmt(Node->getTryBlock());
528 for (unsigned i = 0, e = Node->getNumHandlers(); i < e; ++i) {
530 PrintRawCXXCatchStmt(Node->getHandler(i));
535 void StmtPrinter::VisitSEHTryStmt(SEHTryStmt *Node) {
536 Indent() << (Node->getIsCXXTry() ? "try " : "__try ");
537 PrintRawCompoundStmt(Node->getTryBlock());
538 SEHExceptStmt *E = Node->getExceptHandler();
539 SEHFinallyStmt *F = Node->getFinallyHandler();
541 PrintRawSEHExceptHandler(E);
543 assert(F && "Must have a finally block...");
544 PrintRawSEHFinallyStmt(F);
549 void StmtPrinter::PrintRawSEHFinallyStmt(SEHFinallyStmt *Node) {
551 PrintRawCompoundStmt(Node->getBlock());
555 void StmtPrinter::PrintRawSEHExceptHandler(SEHExceptStmt *Node) {
557 VisitExpr(Node->getFilterExpr());
559 PrintRawCompoundStmt(Node->getBlock());
563 void StmtPrinter::VisitSEHExceptStmt(SEHExceptStmt *Node) {
565 PrintRawSEHExceptHandler(Node);
569 void StmtPrinter::VisitSEHFinallyStmt(SEHFinallyStmt *Node) {
571 PrintRawSEHFinallyStmt(Node);
575 //===----------------------------------------------------------------------===//
576 // Expr printing methods.
577 //===----------------------------------------------------------------------===//
579 void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
580 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
581 Qualifier->print(OS, Policy);
582 if (Node->hasTemplateKeyword())
584 OS << Node->getNameInfo();
585 if (Node->hasExplicitTemplateArgs())
586 OS << TemplateSpecializationType::PrintTemplateArgumentList(
587 Node->getTemplateArgs(),
588 Node->getNumTemplateArgs(),
592 void StmtPrinter::VisitDependentScopeDeclRefExpr(
593 DependentScopeDeclRefExpr *Node) {
594 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
595 Qualifier->print(OS, Policy);
596 if (Node->hasTemplateKeyword())
598 OS << Node->getNameInfo();
599 if (Node->hasExplicitTemplateArgs())
600 OS << TemplateSpecializationType::PrintTemplateArgumentList(
601 Node->getTemplateArgs(),
602 Node->getNumTemplateArgs(),
606 void StmtPrinter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) {
607 if (Node->getQualifier())
608 Node->getQualifier()->print(OS, Policy);
609 if (Node->hasTemplateKeyword())
611 OS << Node->getNameInfo();
612 if (Node->hasExplicitTemplateArgs())
613 OS << TemplateSpecializationType::PrintTemplateArgumentList(
614 Node->getTemplateArgs(),
615 Node->getNumTemplateArgs(),
619 void StmtPrinter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
620 if (Node->getBase()) {
621 PrintExpr(Node->getBase());
622 OS << (Node->isArrow() ? "->" : ".");
624 OS << *Node->getDecl();
627 void StmtPrinter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
628 if (Node->isSuperReceiver())
630 else if (Node->getBase()) {
631 PrintExpr(Node->getBase());
635 if (Node->isImplicitProperty())
636 OS << Node->getImplicitPropertyGetter()->getSelector().getAsString();
638 OS << Node->getExplicitProperty()->getName();
641 void StmtPrinter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *Node) {
643 PrintExpr(Node->getBaseExpr());
645 PrintExpr(Node->getKeyExpr());
649 void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) {
650 switch (Node->getIdentType()) {
652 llvm_unreachable("unknown case");
653 case PredefinedExpr::Func:
656 case PredefinedExpr::Function:
657 OS << "__FUNCTION__";
659 case PredefinedExpr::LFunction:
660 OS << "L__FUNCTION__";
662 case PredefinedExpr::PrettyFunction:
663 OS << "__PRETTY_FUNCTION__";
668 void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) {
669 unsigned value = Node->getValue();
671 switch (Node->getKind()) {
672 case CharacterLiteral::Ascii: break; // no prefix.
673 case CharacterLiteral::Wide: OS << 'L'; break;
674 case CharacterLiteral::UTF16: OS << 'u'; break;
675 case CharacterLiteral::UTF32: OS << 'U'; break;
686 // TODO: K&R: the meaning of '\\a' is different in traditional C
692 // Nonstandard escape sequence.
712 if (value < 256 && isprint(value)) {
713 OS << "'" << (char)value << "'";
714 } else if (value < 256) {
716 OS.write_hex(value) << "'";
718 // FIXME what to really do here?
724 void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) {
725 bool isSigned = Node->getType()->isSignedIntegerType();
726 OS << Node->getValue().toString(10, isSigned);
728 // Emit suffixes. Integer literals are always a builtin integer type.
729 switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
730 default: llvm_unreachable("Unexpected type for integer literal!");
731 // FIXME: The Short and UShort cases are to handle cases where a short
732 // integeral literal is formed during template instantiation. They should
733 // be removed when template instantiation no longer needs integer literals.
734 case BuiltinType::Short:
735 case BuiltinType::UShort:
736 case BuiltinType::Int: break; // no suffix.
737 case BuiltinType::UInt: OS << 'U'; break;
738 case BuiltinType::Long: OS << 'L'; break;
739 case BuiltinType::ULong: OS << "UL"; break;
740 case BuiltinType::LongLong: OS << "LL"; break;
741 case BuiltinType::ULongLong: OS << "ULL"; break;
742 case BuiltinType::Int128: OS << "i128"; break;
743 case BuiltinType::UInt128: OS << "Ui128"; break;
747 static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node,
750 Node->getValue().toString(Str);
752 if (Str.find_first_not_of("-0123456789") == StringRef::npos)
753 OS << '.'; // Trailing dot in order to separate from ints.
758 // Emit suffixes. Float literals are always a builtin float type.
759 switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
760 default: llvm_unreachable("Unexpected type for float literal!");
761 case BuiltinType::Half: break; // FIXME: suffix?
762 case BuiltinType::Double: break; // no suffix.
763 case BuiltinType::Float: OS << 'F'; break;
764 case BuiltinType::LongDouble: OS << 'L'; break;
768 void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) {
769 PrintFloatingLiteral(OS, Node, /*PrintSuffix=*/true);
772 void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) {
773 PrintExpr(Node->getSubExpr());
777 void StmtPrinter::VisitStringLiteral(StringLiteral *Str) {
778 Str->outputString(OS);
780 void StmtPrinter::VisitParenExpr(ParenExpr *Node) {
782 PrintExpr(Node->getSubExpr());
785 void StmtPrinter::VisitUnaryOperator(UnaryOperator *Node) {
786 if (!Node->isPostfix()) {
787 OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
789 // Print a space if this is an "identifier operator" like __real, or if
790 // it might be concatenated incorrectly like '+'.
791 switch (Node->getOpcode()) {
800 if (isa<UnaryOperator>(Node->getSubExpr()))
805 PrintExpr(Node->getSubExpr());
807 if (Node->isPostfix())
808 OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
811 void StmtPrinter::VisitOffsetOfExpr(OffsetOfExpr *Node) {
812 OS << "__builtin_offsetof(";
813 OS << Node->getTypeSourceInfo()->getType().getAsString(Policy) << ", ";
814 bool PrintedSomething = false;
815 for (unsigned i = 0, n = Node->getNumComponents(); i < n; ++i) {
816 OffsetOfExpr::OffsetOfNode ON = Node->getComponent(i);
817 if (ON.getKind() == OffsetOfExpr::OffsetOfNode::Array) {
820 PrintExpr(Node->getIndexExpr(ON.getArrayExprIndex()));
822 PrintedSomething = true;
826 // Skip implicit base indirections.
827 if (ON.getKind() == OffsetOfExpr::OffsetOfNode::Base)
830 // Field or identifier node.
831 IdentifierInfo *Id = ON.getFieldName();
835 if (PrintedSomething)
838 PrintedSomething = true;
844 void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node){
845 switch(Node->getKind()) {
850 if (Policy.LangOpts.CPlusPlus)
852 else if (Policy.LangOpts.C11)
861 if (Node->isArgumentType())
862 OS << "(" << Node->getArgumentType().getAsString(Policy) << ")";
865 PrintExpr(Node->getArgumentExpr());
869 void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) {
871 PrintExpr(Node->getControllingExpr());
872 for (unsigned i = 0; i != Node->getNumAssocs(); ++i) {
874 QualType T = Node->getAssocType(i);
878 OS << T.getAsString(Policy);
880 PrintExpr(Node->getAssocExpr(i));
885 void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) {
886 PrintExpr(Node->getLHS());
888 PrintExpr(Node->getRHS());
892 void StmtPrinter::PrintCallArgs(CallExpr *Call) {
893 for (unsigned i = 0, e = Call->getNumArgs(); i != e; ++i) {
894 if (isa<CXXDefaultArgExpr>(Call->getArg(i))) {
895 // Don't print any defaulted arguments
900 PrintExpr(Call->getArg(i));
904 void StmtPrinter::VisitCallExpr(CallExpr *Call) {
905 PrintExpr(Call->getCallee());
910 void StmtPrinter::VisitMemberExpr(MemberExpr *Node) {
911 // FIXME: Suppress printing implicit bases (like "this")
912 PrintExpr(Node->getBase());
913 if (FieldDecl *FD = dyn_cast<FieldDecl>(Node->getMemberDecl()))
914 if (FD->isAnonymousStructOrUnion())
916 OS << (Node->isArrow() ? "->" : ".");
917 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
918 Qualifier->print(OS, Policy);
919 if (Node->hasTemplateKeyword())
921 OS << Node->getMemberNameInfo();
922 if (Node->hasExplicitTemplateArgs())
923 OS << TemplateSpecializationType::PrintTemplateArgumentList(
924 Node->getTemplateArgs(),
925 Node->getNumTemplateArgs(),
928 void StmtPrinter::VisitObjCIsaExpr(ObjCIsaExpr *Node) {
929 PrintExpr(Node->getBase());
930 OS << (Node->isArrow() ? "->isa" : ".isa");
933 void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
934 PrintExpr(Node->getBase());
936 OS << Node->getAccessor().getName();
938 void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) {
939 OS << "(" << Node->getTypeAsWritten().getAsString(Policy) << ")";
940 PrintExpr(Node->getSubExpr());
942 void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) {
943 OS << "(" << Node->getType().getAsString(Policy) << ")";
944 PrintExpr(Node->getInitializer());
946 void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
947 // No need to print anything, simply forward to the sub expression.
948 PrintExpr(Node->getSubExpr());
950 void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) {
951 PrintExpr(Node->getLHS());
952 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
953 PrintExpr(Node->getRHS());
955 void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
956 PrintExpr(Node->getLHS());
957 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
958 PrintExpr(Node->getRHS());
960 void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) {
961 PrintExpr(Node->getCond());
963 PrintExpr(Node->getLHS());
965 PrintExpr(Node->getRHS());
971 StmtPrinter::VisitBinaryConditionalOperator(BinaryConditionalOperator *Node) {
972 PrintExpr(Node->getCommon());
974 PrintExpr(Node->getFalseExpr());
976 void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) {
977 OS << "&&" << Node->getLabel()->getName();
980 void StmtPrinter::VisitStmtExpr(StmtExpr *E) {
982 PrintRawCompoundStmt(E->getSubStmt());
986 void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) {
987 OS << "__builtin_choose_expr(";
988 PrintExpr(Node->getCond());
990 PrintExpr(Node->getLHS());
992 PrintExpr(Node->getRHS());
996 void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {
1000 void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) {
1001 OS << "__builtin_shufflevector(";
1002 for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) {
1004 PrintExpr(Node->getExpr(i));
1009 void StmtPrinter::VisitInitListExpr(InitListExpr* Node) {
1010 if (Node->getSyntacticForm()) {
1011 Visit(Node->getSyntacticForm());
1016 for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) {
1018 if (Node->getInit(i))
1019 PrintExpr(Node->getInit(i));
1026 void StmtPrinter::VisitParenListExpr(ParenListExpr* Node) {
1028 for (unsigned i = 0, e = Node->getNumExprs(); i != e; ++i) {
1030 PrintExpr(Node->getExpr(i));
1035 void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) {
1036 for (DesignatedInitExpr::designators_iterator D = Node->designators_begin(),
1037 DEnd = Node->designators_end();
1039 if (D->isFieldDesignator()) {
1040 if (D->getDotLoc().isInvalid())
1041 OS << D->getFieldName()->getName() << ":";
1043 OS << "." << D->getFieldName()->getName();
1046 if (D->isArrayDesignator()) {
1047 PrintExpr(Node->getArrayIndex(*D));
1049 PrintExpr(Node->getArrayRangeStart(*D));
1051 PrintExpr(Node->getArrayRangeEnd(*D));
1058 PrintExpr(Node->getInit());
1061 void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) {
1062 if (Policy.LangOpts.CPlusPlus)
1063 OS << "/*implicit*/" << Node->getType().getAsString(Policy) << "()";
1065 OS << "/*implicit*/(" << Node->getType().getAsString(Policy) << ")";
1066 if (Node->getType()->isRecordType())
1073 void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) {
1074 OS << "__builtin_va_arg(";
1075 PrintExpr(Node->getSubExpr());
1077 OS << Node->getType().getAsString(Policy);
1081 void StmtPrinter::VisitPseudoObjectExpr(PseudoObjectExpr *Node) {
1082 PrintExpr(Node->getSyntacticForm());
1085 void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) {
1086 const char *Name = 0;
1087 switch (Node->getOp()) {
1088 #define BUILTIN(ID, TYPE, ATTRS)
1089 #define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
1090 case AtomicExpr::AO ## ID: \
1093 #include "clang/Basic/Builtins.def"
1097 // AtomicExpr stores its subexpressions in a permuted order.
1098 PrintExpr(Node->getPtr());
1100 if (Node->getOp() != AtomicExpr::AO__c11_atomic_load &&
1101 Node->getOp() != AtomicExpr::AO__atomic_load_n) {
1102 PrintExpr(Node->getVal1());
1105 if (Node->getOp() == AtomicExpr::AO__atomic_exchange ||
1106 Node->isCmpXChg()) {
1107 PrintExpr(Node->getVal2());
1110 if (Node->getOp() == AtomicExpr::AO__atomic_compare_exchange ||
1111 Node->getOp() == AtomicExpr::AO__atomic_compare_exchange_n) {
1112 PrintExpr(Node->getWeak());
1115 if (Node->getOp() != AtomicExpr::AO__c11_atomic_init)
1116 PrintExpr(Node->getOrder());
1117 if (Node->isCmpXChg()) {
1119 PrintExpr(Node->getOrderFail());
1125 void StmtPrinter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *Node) {
1126 const char *OpStrings[NUM_OVERLOADED_OPERATORS] = {
1128 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
1130 #include "clang/Basic/OperatorKinds.def"
1133 OverloadedOperatorKind Kind = Node->getOperator();
1134 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
1135 if (Node->getNumArgs() == 1) {
1136 OS << OpStrings[Kind] << ' ';
1137 PrintExpr(Node->getArg(0));
1139 PrintExpr(Node->getArg(0));
1140 OS << ' ' << OpStrings[Kind];
1142 } else if (Kind == OO_Arrow) {
1143 PrintExpr(Node->getArg(0));
1144 } else if (Kind == OO_Call) {
1145 PrintExpr(Node->getArg(0));
1147 for (unsigned ArgIdx = 1; ArgIdx < Node->getNumArgs(); ++ArgIdx) {
1150 if (!isa<CXXDefaultArgExpr>(Node->getArg(ArgIdx)))
1151 PrintExpr(Node->getArg(ArgIdx));
1154 } else if (Kind == OO_Subscript) {
1155 PrintExpr(Node->getArg(0));
1157 PrintExpr(Node->getArg(1));
1159 } else if (Node->getNumArgs() == 1) {
1160 OS << OpStrings[Kind] << ' ';
1161 PrintExpr(Node->getArg(0));
1162 } else if (Node->getNumArgs() == 2) {
1163 PrintExpr(Node->getArg(0));
1164 OS << ' ' << OpStrings[Kind] << ' ';
1165 PrintExpr(Node->getArg(1));
1167 llvm_unreachable("unknown overloaded operator");
1171 void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) {
1172 VisitCallExpr(cast<CallExpr>(Node));
1175 void StmtPrinter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *Node) {
1176 PrintExpr(Node->getCallee());
1178 PrintCallArgs(Node->getConfig());
1180 PrintCallArgs(Node);
1184 void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
1185 OS << Node->getCastName() << '<';
1186 OS << Node->getTypeAsWritten().getAsString(Policy) << ">(";
1187 PrintExpr(Node->getSubExpr());
1191 void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) {
1192 VisitCXXNamedCastExpr(Node);
1195 void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) {
1196 VisitCXXNamedCastExpr(Node);
1199 void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
1200 VisitCXXNamedCastExpr(Node);
1203 void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
1204 VisitCXXNamedCastExpr(Node);
1207 void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) {
1209 if (Node->isTypeOperand()) {
1210 OS << Node->getTypeOperand().getAsString(Policy);
1212 PrintExpr(Node->getExprOperand());
1217 void StmtPrinter::VisitCXXUuidofExpr(CXXUuidofExpr *Node) {
1219 if (Node->isTypeOperand()) {
1220 OS << Node->getTypeOperand().getAsString(Policy);
1222 PrintExpr(Node->getExprOperand());
1227 void StmtPrinter::VisitUserDefinedLiteral(UserDefinedLiteral *Node) {
1228 switch (Node->getLiteralOperatorKind()) {
1229 case UserDefinedLiteral::LOK_Raw:
1230 OS << cast<StringLiteral>(Node->getArg(0)->IgnoreImpCasts())->getString();
1232 case UserDefinedLiteral::LOK_Template: {
1233 DeclRefExpr *DRE = cast<DeclRefExpr>(Node->getCallee()->IgnoreImpCasts());
1234 const TemplateArgumentList *Args =
1235 cast<FunctionDecl>(DRE->getDecl())->getTemplateSpecializationArgs();
1237 const TemplateArgument &Pack = Args->get(0);
1238 for (TemplateArgument::pack_iterator I = Pack.pack_begin(),
1239 E = Pack.pack_end(); I != E; ++I) {
1240 char C = (char)I->getAsIntegral().getZExtValue();
1245 case UserDefinedLiteral::LOK_Integer: {
1246 // Print integer literal without suffix.
1247 IntegerLiteral *Int = cast<IntegerLiteral>(Node->getCookedLiteral());
1248 OS << Int->getValue().toString(10, /*isSigned*/false);
1251 case UserDefinedLiteral::LOK_Floating: {
1252 // Print floating literal without suffix.
1253 FloatingLiteral *Float = cast<FloatingLiteral>(Node->getCookedLiteral());
1254 PrintFloatingLiteral(OS, Float, /*PrintSuffix=*/false);
1257 case UserDefinedLiteral::LOK_String:
1258 case UserDefinedLiteral::LOK_Character:
1259 PrintExpr(Node->getCookedLiteral());
1262 OS << Node->getUDSuffix()->getName();
1265 void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
1266 OS << (Node->getValue() ? "true" : "false");
1269 void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) {
1273 void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) {
1277 void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) {
1278 if (Node->getSubExpr() == 0)
1282 PrintExpr(Node->getSubExpr());
1286 void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
1287 // Nothing to print: we picked up the default argument
1290 void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
1291 OS << Node->getType().getAsString(Policy);
1293 PrintExpr(Node->getSubExpr());
1297 void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
1298 PrintExpr(Node->getSubExpr());
1301 void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) {
1302 OS << Node->getType().getAsString(Policy);
1304 for (CXXTemporaryObjectExpr::arg_iterator Arg = Node->arg_begin(),
1305 ArgEnd = Node->arg_end();
1306 Arg != ArgEnd; ++Arg) {
1307 if (Arg != Node->arg_begin())
1314 void StmtPrinter::VisitLambdaExpr(LambdaExpr *Node) {
1316 bool NeedComma = false;
1317 switch (Node->getCaptureDefault()) {
1331 for (LambdaExpr::capture_iterator C = Node->explicit_capture_begin(),
1332 CEnd = Node->explicit_capture_end();
1339 switch (C->getCaptureKind()) {
1345 if (Node->getCaptureDefault() != LCD_ByRef)
1347 OS << C->getCapturedVar()->getName();
1351 if (Node->getCaptureDefault() != LCD_ByCopy)
1353 OS << C->getCapturedVar()->getName();
1359 if (Node->hasExplicitParameters()) {
1361 CXXMethodDecl *Method = Node->getCallOperator();
1363 for (CXXMethodDecl::param_iterator P = Method->param_begin(),
1364 PEnd = Method->param_end();
1371 std::string ParamStr = (*P)->getNameAsString();
1372 (*P)->getOriginalType().getAsStringInternal(ParamStr, Policy);
1375 if (Method->isVariadic()) {
1382 if (Node->isMutable())
1385 const FunctionProtoType *Proto
1386 = Method->getType()->getAs<FunctionProtoType>();
1388 std::string ExceptionSpec;
1389 Proto->printExceptionSpecification(ExceptionSpec, Policy);
1390 OS << ExceptionSpec;
1393 // FIXME: Attributes
1395 // Print the trailing return type if it was specified in the source.
1396 if (Node->hasExplicitResultType())
1397 OS << " -> " << Proto->getResultType().getAsString(Policy);
1401 CompoundStmt *Body = Node->getBody();
1406 void StmtPrinter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *Node) {
1407 if (TypeSourceInfo *TSInfo = Node->getTypeSourceInfo())
1408 OS << TSInfo->getType().getAsString(Policy) << "()";
1410 OS << Node->getType().getAsString(Policy) << "()";
1413 void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) {
1414 if (E->isGlobalNew())
1417 unsigned NumPlace = E->getNumPlacementArgs();
1418 if (NumPlace > 0 && !isa<CXXDefaultArgExpr>(E->getPlacementArg(0))) {
1420 PrintExpr(E->getPlacementArg(0));
1421 for (unsigned i = 1; i < NumPlace; ++i) {
1422 if (isa<CXXDefaultArgExpr>(E->getPlacementArg(i)))
1425 PrintExpr(E->getPlacementArg(i));
1429 if (E->isParenTypeId())
1432 if (Expr *Size = E->getArraySize()) {
1433 llvm::raw_string_ostream s(TypeS);
1434 Size->printPretty(s, Helper, Policy);
1436 TypeS = "[" + TypeS + "]";
1438 E->getAllocatedType().getAsStringInternal(TypeS, Policy);
1440 if (E->isParenTypeId())
1443 CXXNewExpr::InitializationStyle InitStyle = E->getInitializationStyle();
1445 if (InitStyle == CXXNewExpr::CallInit)
1447 PrintExpr(E->getInitializer());
1448 if (InitStyle == CXXNewExpr::CallInit)
1453 void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1454 if (E->isGlobalDelete())
1457 if (E->isArrayForm())
1459 PrintExpr(E->getArgument());
1462 void StmtPrinter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1463 PrintExpr(E->getBase());
1468 if (E->getQualifier())
1469 E->getQualifier()->print(OS, Policy);
1473 if (IdentifierInfo *II = E->getDestroyedTypeIdentifier())
1474 OS << II->getName();
1476 E->getDestroyedType().getAsStringInternal(TypeS, Policy);
1480 void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1481 for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
1482 if (isa<CXXDefaultArgExpr>(E->getArg(i))) {
1483 // Don't print any defaulted arguments
1488 PrintExpr(E->getArg(i));
1492 void StmtPrinter::VisitExprWithCleanups(ExprWithCleanups *E) {
1493 // Just forward to the sub expression.
1494 PrintExpr(E->getSubExpr());
1498 StmtPrinter::VisitCXXUnresolvedConstructExpr(
1499 CXXUnresolvedConstructExpr *Node) {
1500 OS << Node->getTypeAsWritten().getAsString(Policy);
1502 for (CXXUnresolvedConstructExpr::arg_iterator Arg = Node->arg_begin(),
1503 ArgEnd = Node->arg_end();
1504 Arg != ArgEnd; ++Arg) {
1505 if (Arg != Node->arg_begin())
1512 void StmtPrinter::VisitCXXDependentScopeMemberExpr(
1513 CXXDependentScopeMemberExpr *Node) {
1514 if (!Node->isImplicitAccess()) {
1515 PrintExpr(Node->getBase());
1516 OS << (Node->isArrow() ? "->" : ".");
1518 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
1519 Qualifier->print(OS, Policy);
1520 if (Node->hasTemplateKeyword())
1522 OS << Node->getMemberNameInfo();
1523 if (Node->hasExplicitTemplateArgs()) {
1524 OS << TemplateSpecializationType::PrintTemplateArgumentList(
1525 Node->getTemplateArgs(),
1526 Node->getNumTemplateArgs(),
1531 void StmtPrinter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *Node) {
1532 if (!Node->isImplicitAccess()) {
1533 PrintExpr(Node->getBase());
1534 OS << (Node->isArrow() ? "->" : ".");
1536 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
1537 Qualifier->print(OS, Policy);
1538 if (Node->hasTemplateKeyword())
1540 OS << Node->getMemberNameInfo();
1541 if (Node->hasExplicitTemplateArgs()) {
1542 OS << TemplateSpecializationType::PrintTemplateArgumentList(
1543 Node->getTemplateArgs(),
1544 Node->getNumTemplateArgs(),
1549 static const char *getTypeTraitName(UnaryTypeTrait UTT) {
1551 case UTT_HasNothrowAssign: return "__has_nothrow_assign";
1552 case UTT_HasNothrowConstructor: return "__has_nothrow_constructor";
1553 case UTT_HasNothrowCopy: return "__has_nothrow_copy";
1554 case UTT_HasTrivialAssign: return "__has_trivial_assign";
1555 case UTT_HasTrivialDefaultConstructor: return "__has_trivial_constructor";
1556 case UTT_HasTrivialCopy: return "__has_trivial_copy";
1557 case UTT_HasTrivialDestructor: return "__has_trivial_destructor";
1558 case UTT_HasVirtualDestructor: return "__has_virtual_destructor";
1559 case UTT_IsAbstract: return "__is_abstract";
1560 case UTT_IsArithmetic: return "__is_arithmetic";
1561 case UTT_IsArray: return "__is_array";
1562 case UTT_IsClass: return "__is_class";
1563 case UTT_IsCompleteType: return "__is_complete_type";
1564 case UTT_IsCompound: return "__is_compound";
1565 case UTT_IsConst: return "__is_const";
1566 case UTT_IsEmpty: return "__is_empty";
1567 case UTT_IsEnum: return "__is_enum";
1568 case UTT_IsFinal: return "__is_final";
1569 case UTT_IsFloatingPoint: return "__is_floating_point";
1570 case UTT_IsFunction: return "__is_function";
1571 case UTT_IsFundamental: return "__is_fundamental";
1572 case UTT_IsIntegral: return "__is_integral";
1573 case UTT_IsInterfaceClass: return "__is_interface_class";
1574 case UTT_IsLiteral: return "__is_literal";
1575 case UTT_IsLvalueReference: return "__is_lvalue_reference";
1576 case UTT_IsMemberFunctionPointer: return "__is_member_function_pointer";
1577 case UTT_IsMemberObjectPointer: return "__is_member_object_pointer";
1578 case UTT_IsMemberPointer: return "__is_member_pointer";
1579 case UTT_IsObject: return "__is_object";
1580 case UTT_IsPOD: return "__is_pod";
1581 case UTT_IsPointer: return "__is_pointer";
1582 case UTT_IsPolymorphic: return "__is_polymorphic";
1583 case UTT_IsReference: return "__is_reference";
1584 case UTT_IsRvalueReference: return "__is_rvalue_reference";
1585 case UTT_IsScalar: return "__is_scalar";
1586 case UTT_IsSigned: return "__is_signed";
1587 case UTT_IsStandardLayout: return "__is_standard_layout";
1588 case UTT_IsTrivial: return "__is_trivial";
1589 case UTT_IsTriviallyCopyable: return "__is_trivially_copyable";
1590 case UTT_IsUnion: return "__is_union";
1591 case UTT_IsUnsigned: return "__is_unsigned";
1592 case UTT_IsVoid: return "__is_void";
1593 case UTT_IsVolatile: return "__is_volatile";
1595 llvm_unreachable("Type trait not covered by switch statement");
1598 static const char *getTypeTraitName(BinaryTypeTrait BTT) {
1600 case BTT_IsBaseOf: return "__is_base_of";
1601 case BTT_IsConvertible: return "__is_convertible";
1602 case BTT_IsSame: return "__is_same";
1603 case BTT_TypeCompatible: return "__builtin_types_compatible_p";
1604 case BTT_IsConvertibleTo: return "__is_convertible_to";
1605 case BTT_IsTriviallyAssignable: return "__is_trivially_assignable";
1607 llvm_unreachable("Binary type trait not covered by switch");
1610 static const char *getTypeTraitName(TypeTrait TT) {
1612 case clang::TT_IsTriviallyConstructible:return "__is_trivially_constructible";
1614 llvm_unreachable("Type trait not covered by switch");
1617 static const char *getTypeTraitName(ArrayTypeTrait ATT) {
1619 case ATT_ArrayRank: return "__array_rank";
1620 case ATT_ArrayExtent: return "__array_extent";
1622 llvm_unreachable("Array type trait not covered by switch");
1625 static const char *getExpressionTraitName(ExpressionTrait ET) {
1627 case ET_IsLValueExpr: return "__is_lvalue_expr";
1628 case ET_IsRValueExpr: return "__is_rvalue_expr";
1630 llvm_unreachable("Expression type trait not covered by switch");
1633 void StmtPrinter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1634 OS << getTypeTraitName(E->getTrait()) << "("
1635 << E->getQueriedType().getAsString(Policy) << ")";
1638 void StmtPrinter::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1639 OS << getTypeTraitName(E->getTrait()) << "("
1640 << E->getLhsType().getAsString(Policy) << ","
1641 << E->getRhsType().getAsString(Policy) << ")";
1644 void StmtPrinter::VisitTypeTraitExpr(TypeTraitExpr *E) {
1645 OS << getTypeTraitName(E->getTrait()) << "(";
1646 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
1649 OS << E->getArg(I)->getType().getAsString(Policy);
1654 void StmtPrinter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1655 OS << getTypeTraitName(E->getTrait()) << "("
1656 << E->getQueriedType().getAsString(Policy) << ")";
1659 void StmtPrinter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1660 OS << getExpressionTraitName(E->getTrait()) << "(";
1661 PrintExpr(E->getQueriedExpression());
1665 void StmtPrinter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1667 PrintExpr(E->getOperand());
1671 void StmtPrinter::VisitPackExpansionExpr(PackExpansionExpr *E) {
1672 PrintExpr(E->getPattern());
1676 void StmtPrinter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1677 OS << "sizeof...(" << *E->getPack() << ")";
1680 void StmtPrinter::VisitSubstNonTypeTemplateParmPackExpr(
1681 SubstNonTypeTemplateParmPackExpr *Node) {
1682 OS << *Node->getParameterPack();
1685 void StmtPrinter::VisitSubstNonTypeTemplateParmExpr(
1686 SubstNonTypeTemplateParmExpr *Node) {
1687 Visit(Node->getReplacement());
1690 void StmtPrinter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1691 OS << *E->getParameterPack();
1694 void StmtPrinter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *Node){
1695 PrintExpr(Node->GetTemporaryExpr());
1700 void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) {
1702 VisitStringLiteral(Node->getString());
1705 void StmtPrinter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1707 Visit(E->getSubExpr());
1710 void StmtPrinter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1712 StmtRange ch = E->children();
1713 if (ch.first != ch.second) {
1717 if (ch.first == ch.second) break;
1724 void StmtPrinter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1726 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
1730 ObjCDictionaryElement Element = E->getKeyValueElement(I);
1733 Visit(Element.Value);
1734 if (Element.isPackExpansion())
1740 void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
1741 OS << "@encode(" << Node->getEncodedType().getAsString(Policy) << ')';
1744 void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
1745 OS << "@selector(" << Node->getSelector().getAsString() << ')';
1748 void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
1749 OS << "@protocol(" << *Node->getProtocol() << ')';
1752 void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) {
1754 switch (Mess->getReceiverKind()) {
1755 case ObjCMessageExpr::Instance:
1756 PrintExpr(Mess->getInstanceReceiver());
1759 case ObjCMessageExpr::Class:
1760 OS << Mess->getClassReceiver().getAsString(Policy);
1763 case ObjCMessageExpr::SuperInstance:
1764 case ObjCMessageExpr::SuperClass:
1770 Selector selector = Mess->getSelector();
1771 if (selector.isUnarySelector()) {
1772 OS << selector.getNameForSlot(0);
1774 for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) {
1775 if (i < selector.getNumArgs()) {
1776 if (i > 0) OS << ' ';
1777 if (selector.getIdentifierInfoForSlot(i))
1778 OS << selector.getIdentifierInfoForSlot(i)->getName() << ':';
1782 else OS << ", "; // Handle variadic methods.
1784 PrintExpr(Mess->getArg(i));
1790 void StmtPrinter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Node) {
1791 OS << (Node->getValue() ? "__objc_yes" : "__objc_no");
1795 StmtPrinter::VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
1796 PrintExpr(E->getSubExpr());
1800 StmtPrinter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
1801 OS << "(" << E->getBridgeKindName() << E->getType().getAsString(Policy)
1803 PrintExpr(E->getSubExpr());
1806 void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
1807 BlockDecl *BD = Node->getBlockDecl();
1810 const FunctionType *AFT = Node->getFunctionType();
1812 if (isa<FunctionNoProtoType>(AFT)) {
1814 } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) {
1816 std::string ParamStr;
1817 for (BlockDecl::param_iterator AI = BD->param_begin(),
1818 E = BD->param_end(); AI != E; ++AI) {
1819 if (AI != BD->param_begin()) OS << ", ";
1820 ParamStr = (*AI)->getNameAsString();
1821 (*AI)->getType().getAsStringInternal(ParamStr, Policy);
1825 const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
1826 if (FT->isVariadic()) {
1827 if (!BD->param_empty()) OS << ", ";
1834 void StmtPrinter::VisitOpaqueValueExpr(OpaqueValueExpr *Node) {
1835 PrintExpr(Node->getSourceExpr());
1838 void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) {
1839 OS << "__builtin_astype(";
1840 PrintExpr(Node->getSrcExpr());
1841 OS << ", " << Node->getType().getAsString();
1845 //===----------------------------------------------------------------------===//
1846 // Stmt method implementations
1847 //===----------------------------------------------------------------------===//
1849 void Stmt::dumpPretty(ASTContext &Context) const {
1850 printPretty(llvm::errs(), 0, PrintingPolicy(Context.getLangOpts()));
1853 void Stmt::printPretty(raw_ostream &OS,
1854 PrinterHelper *Helper,
1855 const PrintingPolicy &Policy,
1856 unsigned Indentation) const {
1862 if (Policy.DumpSourceManager) {
1863 dump(OS, *Policy.DumpSourceManager);
1867 StmtPrinter P(OS, Helper, Policy, Indentation);
1868 P.Visit(const_cast<Stmt*>(this));
1871 //===----------------------------------------------------------------------===//
1873 //===----------------------------------------------------------------------===//
1875 // Implement virtual destructor.
1876 PrinterHelper::~PrinterHelper() {}