Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 1 | //===--- StmtDumper.cpp - Dumping implementation for Stmt ASTs ------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 0bc735f | 2007-12-29 19:59:25 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file implements the Stmt::dump/Stmt::print methods, which dump out the |
| 11 | // AST in a form that exposes type details and other fields. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | #include "clang/AST/StmtVisitor.h" |
Benjamin Kramer | 478851c | 2012-07-04 17:04:04 +0000 | [diff] [blame] | 16 | #include "clang/AST/ASTContext.h" |
Ted Kremenek | 91d1d7a | 2007-10-17 18:36:42 +0000 | [diff] [blame] | 17 | #include "clang/AST/DeclObjC.h" |
Douglas Gregor | 2a3009a | 2009-02-03 19:21:40 +0000 | [diff] [blame] | 18 | #include "clang/AST/DeclCXX.h" |
Douglas Gregor | d249e1d1f | 2009-05-29 20:38:28 +0000 | [diff] [blame] | 19 | #include "clang/AST/PrettyPrinter.h" |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 20 | #include "clang/Basic/SourceManager.h" |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 21 | #include "llvm/Support/raw_ostream.h" |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 22 | using namespace clang; |
| 23 | |
| 24 | //===----------------------------------------------------------------------===// |
| 25 | // StmtDumper Visitor |
| 26 | //===----------------------------------------------------------------------===// |
| 27 | |
| 28 | namespace { |
Benjamin Kramer | 770b4a8 | 2009-11-28 19:03:38 +0000 | [diff] [blame] | 29 | class StmtDumper : public StmtVisitor<StmtDumper> { |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 30 | SourceManager *SM; |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 31 | raw_ostream &OS; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 32 | unsigned IndentLevel; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 33 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 34 | /// MaxDepth - When doing a normal dump (not dumpAll) we only want to dump |
| 35 | /// the first few levels of an AST. This keeps track of how many ast levels |
| 36 | /// are left. |
| 37 | unsigned MaxDepth; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 38 | |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 39 | /// LastLocFilename/LastLocLine - Keep track of the last location we print |
| 40 | /// out so that we can print out deltas from then on out. |
| 41 | const char *LastLocFilename; |
| 42 | unsigned LastLocLine; |
Douglas Gregor | d249e1d1f | 2009-05-29 20:38:28 +0000 | [diff] [blame] | 43 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 44 | public: |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 45 | StmtDumper(SourceManager *sm, raw_ostream &os, unsigned maxDepth) |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 46 | : SM(sm), OS(os), IndentLevel(0-1), MaxDepth(maxDepth) { |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 47 | LastLocFilename = ""; |
| 48 | LastLocLine = ~0U; |
| 49 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 50 | |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 51 | void DumpSubTree(Stmt *S) { |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 52 | // Prune the recursion if not using dump all. |
| 53 | if (MaxDepth == 0) return; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 54 | |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 55 | ++IndentLevel; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 56 | if (S) { |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 57 | if (DeclStmt* DS = dyn_cast<DeclStmt>(S)) |
| 58 | VisitDeclStmt(DS); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 59 | else { |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 60 | Visit(S); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 61 | |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 62 | // Print out children. |
John McCall | 7502c1d | 2011-02-13 04:07:26 +0000 | [diff] [blame] | 63 | Stmt::child_range CI = S->children(); |
| 64 | if (CI) { |
| 65 | while (CI) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 66 | OS << '\n'; |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 67 | DumpSubTree(*CI++); |
| 68 | } |
Chris Lattner | b393879 | 2007-08-30 00:53:54 +0000 | [diff] [blame] | 69 | } |
| 70 | } |
Chris Lattner | a46325e | 2010-05-25 17:56:43 +0000 | [diff] [blame] | 71 | OS << ')'; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 72 | } else { |
| 73 | Indent(); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 74 | OS << "<<<NULL>>>"; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 75 | } |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 76 | --IndentLevel; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 77 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 78 | |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 79 | void DumpDeclarator(Decl *D); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 80 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 81 | void Indent() const { |
| 82 | for (int i = 0, e = IndentLevel; i < e; ++i) |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 83 | OS << " "; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 84 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 85 | |
Steve Naroff | 9dcbfa4 | 2007-09-01 21:08:38 +0000 | [diff] [blame] | 86 | void DumpType(QualType T) { |
John McCall | 49f4e1c | 2010-12-10 11:01:00 +0000 | [diff] [blame] | 87 | SplitQualType T_split = T.split(); |
| 88 | OS << "'" << QualType::getAsString(T_split) << "'"; |
Chris Lattner | fd8f7da | 2007-08-09 00:36:22 +0000 | [diff] [blame] | 89 | |
Douglas Gregor | 61366e9 | 2008-12-24 00:01:03 +0000 | [diff] [blame] | 90 | if (!T.isNull()) { |
John McCall | 0953e76 | 2009-09-24 19:53:00 +0000 | [diff] [blame] | 91 | // If the type is sugared, also dump a (shallow) desugared type. |
John McCall | 49f4e1c | 2010-12-10 11:01:00 +0000 | [diff] [blame] | 92 | SplitQualType D_split = T.getSplitDesugaredType(); |
| 93 | if (T_split != D_split) |
| 94 | OS << ":'" << QualType::getAsString(D_split) << "'"; |
Chris Lattner | bad3785 | 2008-04-02 05:06:23 +0000 | [diff] [blame] | 95 | } |
Chris Lattner | fd8f7da | 2007-08-09 00:36:22 +0000 | [diff] [blame] | 96 | } |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 97 | void DumpDeclRef(Decl *node); |
Steve Naroff | 9dcbfa4 | 2007-09-01 21:08:38 +0000 | [diff] [blame] | 98 | void DumpStmt(const Stmt *Node) { |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 99 | Indent(); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 100 | OS << "(" << Node->getStmtClassName() |
Roman Divacky | 31ba613 | 2012-09-06 15:59:27 +0000 | [diff] [blame] | 101 | << " " << (const void*)Node; |
Steve Naroff | 9dcbfa4 | 2007-09-01 21:08:38 +0000 | [diff] [blame] | 102 | DumpSourceRange(Node); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 103 | } |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 104 | void DumpValueKind(ExprValueKind K) { |
| 105 | switch (K) { |
| 106 | case VK_RValue: break; |
| 107 | case VK_LValue: OS << " lvalue"; break; |
| 108 | case VK_XValue: OS << " xvalue"; break; |
| 109 | } |
| 110 | } |
| 111 | void DumpObjectKind(ExprObjectKind K) { |
| 112 | switch (K) { |
| 113 | case OK_Ordinary: break; |
| 114 | case OK_BitField: OS << " bitfield"; break; |
| 115 | case OK_ObjCProperty: OS << " objcproperty"; break; |
Ted Kremenek | ebcb57a | 2012-03-06 20:05:56 +0000 | [diff] [blame] | 116 | case OK_ObjCSubscript: OS << " objcsubscript"; break; |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 117 | case OK_VectorComponent: OS << " vectorcomponent"; break; |
| 118 | } |
| 119 | } |
Steve Naroff | 9dcbfa4 | 2007-09-01 21:08:38 +0000 | [diff] [blame] | 120 | void DumpExpr(const Expr *Node) { |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 121 | DumpStmt(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 122 | OS << ' '; |
Chris Lattner | fd8f7da | 2007-08-09 00:36:22 +0000 | [diff] [blame] | 123 | DumpType(Node->getType()); |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 124 | DumpValueKind(Node->getValueKind()); |
| 125 | DumpObjectKind(Node->getObjectKind()); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 126 | } |
Steve Naroff | 9dcbfa4 | 2007-09-01 21:08:38 +0000 | [diff] [blame] | 127 | void DumpSourceRange(const Stmt *Node); |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 128 | void DumpLocation(SourceLocation Loc); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 129 | |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 130 | // Stmts. |
Chris Lattner | c5598cb | 2007-08-21 04:04:25 +0000 | [diff] [blame] | 131 | void VisitStmt(Stmt *Node); |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 132 | void VisitDeclStmt(DeclStmt *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 133 | void VisitLabelStmt(LabelStmt *Node); |
| 134 | void VisitGotoStmt(GotoStmt *Node); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 135 | |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 136 | // Exprs |
| 137 | void VisitExpr(Expr *Node); |
Anders Carlsson | 27a5b9b | 2009-08-22 23:33:40 +0000 | [diff] [blame] | 138 | void VisitCastExpr(CastExpr *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 139 | void VisitDeclRefExpr(DeclRefExpr *Node); |
Chris Lattner | d9f6910 | 2008-08-10 01:53:14 +0000 | [diff] [blame] | 140 | void VisitPredefinedExpr(PredefinedExpr *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 141 | void VisitCharacterLiteral(CharacterLiteral *Node); |
| 142 | void VisitIntegerLiteral(IntegerLiteral *Node); |
| 143 | void VisitFloatingLiteral(FloatingLiteral *Node); |
| 144 | void VisitStringLiteral(StringLiteral *Str); |
| 145 | void VisitUnaryOperator(UnaryOperator *Node); |
Peter Collingbourne | f4e3cfb | 2011-03-11 19:24:49 +0000 | [diff] [blame] | 146 | void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 147 | void VisitMemberExpr(MemberExpr *Node); |
Nate Begeman | 213541a | 2008-04-18 23:10:10 +0000 | [diff] [blame] | 148 | void VisitExtVectorElementExpr(ExtVectorElementExpr *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 149 | void VisitBinaryOperator(BinaryOperator *Node); |
| 150 | void VisitCompoundAssignOperator(CompoundAssignOperator *Node); |
| 151 | void VisitAddrLabelExpr(AddrLabelExpr *Node); |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 152 | void VisitBlockExpr(BlockExpr *Node); |
John McCall | 4b9c2d2 | 2011-11-06 09:01:30 +0000 | [diff] [blame] | 153 | void VisitOpaqueValueExpr(OpaqueValueExpr *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 154 | |
| 155 | // C++ |
Douglas Gregor | 49badde | 2008-10-27 19:41:14 +0000 | [diff] [blame] | 156 | void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 157 | void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node); |
Douglas Gregor | cd9b46e | 2008-11-04 14:56:14 +0000 | [diff] [blame] | 158 | void VisitCXXThisExpr(CXXThisExpr *Node); |
Douglas Gregor | 49badde | 2008-10-27 19:41:14 +0000 | [diff] [blame] | 159 | void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node); |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 160 | void VisitCXXConstructExpr(CXXConstructExpr *Node); |
| 161 | void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node); |
John McCall | 4765fa0 | 2010-12-06 08:20:24 +0000 | [diff] [blame] | 162 | void VisitExprWithCleanups(ExprWithCleanups *Node); |
John McCall | 9d5f35e | 2009-12-11 21:50:11 +0000 | [diff] [blame] | 163 | void VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node); |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 164 | void DumpCXXTemporary(CXXTemporary *Temporary); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 165 | |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 166 | // ObjC |
Douglas Gregor | 8f5e3dd | 2010-04-23 22:50:49 +0000 | [diff] [blame] | 167 | void VisitObjCAtCatchStmt(ObjCAtCatchStmt *Node); |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 168 | void VisitObjCEncodeExpr(ObjCEncodeExpr *Node); |
Ted Kremenek | b3d914b | 2008-02-29 22:04:05 +0000 | [diff] [blame] | 169 | void VisitObjCMessageExpr(ObjCMessageExpr* Node); |
Argyrios Kyrtzidis | 36faadd | 2012-05-10 20:02:31 +0000 | [diff] [blame] | 170 | void VisitObjCBoxedExpr(ObjCBoxedExpr* Node); |
Fariborz Jahanian | b62f681 | 2007-10-16 20:40:23 +0000 | [diff] [blame] | 171 | void VisitObjCSelectorExpr(ObjCSelectorExpr *Node); |
Fariborz Jahanian | 390d50a | 2007-10-17 16:58:11 +0000 | [diff] [blame] | 172 | void VisitObjCProtocolExpr(ObjCProtocolExpr *Node); |
Daniel Dunbar | 7f8ea5c | 2008-08-30 05:35:15 +0000 | [diff] [blame] | 173 | void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node); |
Ted Kremenek | ebcb57a | 2012-03-06 20:05:56 +0000 | [diff] [blame] | 174 | void VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *Node); |
Steve Naroff | 3c64d9e | 2008-03-12 13:19:12 +0000 | [diff] [blame] | 175 | void VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node); |
Ted Kremenek | ebcb57a | 2012-03-06 20:05:56 +0000 | [diff] [blame] | 176 | void VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Node); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 177 | }; |
| 178 | } |
| 179 | |
| 180 | //===----------------------------------------------------------------------===// |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 181 | // Utilities |
| 182 | //===----------------------------------------------------------------------===// |
| 183 | |
| 184 | void StmtDumper::DumpLocation(SourceLocation Loc) { |
Chris Lattner | df7c17a | 2009-01-16 07:00:02 +0000 | [diff] [blame] | 185 | SourceLocation SpellingLoc = SM->getSpellingLoc(Loc); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 186 | |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 187 | // The general format we print out is filename:line:col, but we drop pieces |
| 188 | // that haven't changed since the last loc printed. |
Chris Lattner | b9c3f96 | 2009-01-27 07:57:44 +0000 | [diff] [blame] | 189 | PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc); |
| 190 | |
Douglas Gregor | cb7b1e1 | 2010-11-12 07:15:47 +0000 | [diff] [blame] | 191 | if (PLoc.isInvalid()) { |
| 192 | OS << "<invalid sloc>"; |
| 193 | return; |
| 194 | } |
| 195 | |
Chris Lattner | b9c3f96 | 2009-01-27 07:57:44 +0000 | [diff] [blame] | 196 | if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 197 | OS << PLoc.getFilename() << ':' << PLoc.getLine() |
| 198 | << ':' << PLoc.getColumn(); |
Chris Lattner | b9c3f96 | 2009-01-27 07:57:44 +0000 | [diff] [blame] | 199 | LastLocFilename = PLoc.getFilename(); |
| 200 | LastLocLine = PLoc.getLine(); |
| 201 | } else if (PLoc.getLine() != LastLocLine) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 202 | OS << "line" << ':' << PLoc.getLine() |
| 203 | << ':' << PLoc.getColumn(); |
Chris Lattner | b9c3f96 | 2009-01-27 07:57:44 +0000 | [diff] [blame] | 204 | LastLocLine = PLoc.getLine(); |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 205 | } else { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 206 | OS << "col" << ':' << PLoc.getColumn(); |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 207 | } |
| 208 | } |
| 209 | |
Steve Naroff | 9dcbfa4 | 2007-09-01 21:08:38 +0000 | [diff] [blame] | 210 | void StmtDumper::DumpSourceRange(const Stmt *Node) { |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 211 | // Can't translate locations if a SourceManager isn't available. |
| 212 | if (SM == 0) return; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 213 | |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 214 | // TODO: If the parent expression is available, we can print a delta vs its |
| 215 | // location. |
| 216 | SourceRange R = Node->getSourceRange(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 217 | |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 218 | OS << " <"; |
Chris Lattner | 311ff02 | 2007-10-16 22:36:42 +0000 | [diff] [blame] | 219 | DumpLocation(R.getBegin()); |
| 220 | if (R.getBegin() != R.getEnd()) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 221 | OS << ", "; |
Chris Lattner | 311ff02 | 2007-10-16 22:36:42 +0000 | [diff] [blame] | 222 | DumpLocation(R.getEnd()); |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 223 | } |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 224 | OS << ">"; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 225 | |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 226 | // <t2.c:123:421[blah], t2.c:412:321> |
| 227 | |
| 228 | } |
| 229 | |
| 230 | |
| 231 | //===----------------------------------------------------------------------===// |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 232 | // Stmt printing methods. |
| 233 | //===----------------------------------------------------------------------===// |
| 234 | |
| 235 | void StmtDumper::VisitStmt(Stmt *Node) { |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 236 | DumpStmt(Node); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 237 | } |
| 238 | |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 239 | void StmtDumper::DumpDeclarator(Decl *D) { |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 240 | // FIXME: Need to complete/beautify this... this code simply shows the |
| 241 | // nodes are where they need to be. |
| 242 | if (TypedefDecl *localType = dyn_cast<TypedefDecl>(D)) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 243 | OS << "\"typedef " << localType->getUnderlyingType().getAsString() |
Benjamin Kramer | b8989f2 | 2011-10-14 18:45:37 +0000 | [diff] [blame] | 244 | << ' ' << *localType << '"'; |
Richard Smith | 162e1c1 | 2011-04-15 14:24:37 +0000 | [diff] [blame] | 245 | } else if (TypeAliasDecl *localType = dyn_cast<TypeAliasDecl>(D)) { |
Benjamin Kramer | b8989f2 | 2011-10-14 18:45:37 +0000 | [diff] [blame] | 246 | OS << "\"using " << *localType << " = " |
Richard Smith | 162e1c1 | 2011-04-15 14:24:37 +0000 | [diff] [blame] | 247 | << localType->getUnderlyingType().getAsString() << '"'; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 248 | } else if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 249 | OS << "\""; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 250 | // Emit storage class for vardecls. |
| 251 | if (VarDecl *V = dyn_cast<VarDecl>(VD)) { |
John McCall | d931b08 | 2010-08-26 03:08:43 +0000 | [diff] [blame] | 252 | if (V->getStorageClass() != SC_None) |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 253 | OS << VarDecl::getStorageClassSpecifierString(V->getStorageClass()) |
| 254 | << " "; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 255 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 256 | |
Chris Lattner | 39f34e9 | 2008-11-24 04:00:27 +0000 | [diff] [blame] | 257 | std::string Name = VD->getNameAsString(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 258 | VD->getType().getAsStringInternal(Name, |
David Blaikie | 4e4d084 | 2012-03-11 07:00:24 +0000 | [diff] [blame] | 259 | PrintingPolicy(VD->getASTContext().getLangOpts())); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 260 | OS << Name; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 261 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 262 | // If this is a vardecl with an initializer, emit it. |
| 263 | if (VarDecl *V = dyn_cast<VarDecl>(VD)) { |
| 264 | if (V->getInit()) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 265 | OS << " =\n"; |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 266 | DumpSubTree(V->getInit()); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 267 | } |
| 268 | } |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 269 | OS << '"'; |
Steve Naroff | 9219928 | 2007-11-17 21:37:36 +0000 | [diff] [blame] | 270 | } else if (TagDecl *TD = dyn_cast<TagDecl>(D)) { |
| 271 | // print a free standing tag decl (e.g. "struct x;"). |
| 272 | const char *tagname; |
| 273 | if (const IdentifierInfo *II = TD->getIdentifier()) |
Daniel Dunbar | e013d68 | 2009-10-18 20:26:12 +0000 | [diff] [blame] | 274 | tagname = II->getNameStart(); |
Steve Naroff | 9219928 | 2007-11-17 21:37:36 +0000 | [diff] [blame] | 275 | else |
| 276 | tagname = "<anonymous>"; |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 277 | OS << '"' << TD->getKindName() << ' ' << tagname << ";\""; |
Steve Naroff | 9219928 | 2007-11-17 21:37:36 +0000 | [diff] [blame] | 278 | // FIXME: print tag bodies. |
Douglas Gregor | 2a3009a | 2009-02-03 19:21:40 +0000 | [diff] [blame] | 279 | } else if (UsingDirectiveDecl *UD = dyn_cast<UsingDirectiveDecl>(D)) { |
| 280 | // print using-directive decl (e.g. "using namespace x;") |
| 281 | const char *ns; |
| 282 | if (const IdentifierInfo *II = UD->getNominatedNamespace()->getIdentifier()) |
Daniel Dunbar | e013d68 | 2009-10-18 20:26:12 +0000 | [diff] [blame] | 283 | ns = II->getNameStart(); |
Douglas Gregor | 2a3009a | 2009-02-03 19:21:40 +0000 | [diff] [blame] | 284 | else |
| 285 | ns = "<anonymous>"; |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 286 | OS << '"' << UD->getDeclKindName() << ns << ";\""; |
Sebastian Redl | 0ca4359 | 2010-05-04 10:20:17 +0000 | [diff] [blame] | 287 | } else if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) { |
| 288 | // print using decl (e.g. "using std::string;") |
| 289 | const char *tn = UD->isTypeName() ? "typename " : ""; |
| 290 | OS << '"' << UD->getDeclKindName() << tn; |
Douglas Gregor | dc35571 | 2011-02-25 00:36:19 +0000 | [diff] [blame] | 291 | UD->getQualifier()->print(OS, |
David Blaikie | 4e4d084 | 2012-03-11 07:00:24 +0000 | [diff] [blame] | 292 | PrintingPolicy(UD->getASTContext().getLangOpts())); |
Sebastian Redl | 0ca4359 | 2010-05-04 10:20:17 +0000 | [diff] [blame] | 293 | OS << ";\""; |
Chris Lattner | 4ae493c | 2011-02-18 02:08:43 +0000 | [diff] [blame] | 294 | } else if (LabelDecl *LD = dyn_cast<LabelDecl>(D)) { |
Benjamin Kramer | a59d20b | 2012-02-07 11:57:57 +0000 | [diff] [blame] | 295 | OS << "label " << *LD; |
Peter Collingbourne | 28ac87e | 2011-03-16 18:37:27 +0000 | [diff] [blame] | 296 | } else if (StaticAssertDecl *SAD = dyn_cast<StaticAssertDecl>(D)) { |
| 297 | OS << "\"static_assert(\n"; |
| 298 | DumpSubTree(SAD->getAssertExpr()); |
| 299 | OS << ",\n"; |
| 300 | DumpSubTree(SAD->getMessage()); |
| 301 | OS << ");\""; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 302 | } else { |
David Blaikie | b219cfc | 2011-09-23 05:06:16 +0000 | [diff] [blame] | 303 | llvm_unreachable("Unexpected decl"); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 304 | } |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 305 | } |
| 306 | |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 307 | void StmtDumper::VisitDeclStmt(DeclStmt *Node) { |
| 308 | DumpStmt(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 309 | OS << "\n"; |
Ted Kremenek | 04a72b7 | 2008-10-06 18:38:35 +0000 | [diff] [blame] | 310 | for (DeclStmt::decl_iterator DI = Node->decl_begin(), DE = Node->decl_end(); |
| 311 | DI != DE; ++DI) { |
Douglas Gregor | 4afa39d | 2009-01-20 01:17:11 +0000 | [diff] [blame] | 312 | Decl* D = *DI; |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 313 | ++IndentLevel; |
| 314 | Indent(); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 315 | OS << (void*) D << " "; |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 316 | DumpDeclarator(D); |
Chris Lattner | f279725 | 2009-03-29 16:04:50 +0000 | [diff] [blame] | 317 | if (DI+1 != DE) |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 318 | OS << "\n"; |
Ted Kremenek | 5399ce2 | 2007-12-12 06:59:42 +0000 | [diff] [blame] | 319 | --IndentLevel; |
| 320 | } |
| 321 | } |
| 322 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 323 | void StmtDumper::VisitLabelStmt(LabelStmt *Node) { |
| 324 | DumpStmt(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 325 | OS << " '" << Node->getName() << "'"; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 326 | } |
| 327 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 328 | void StmtDumper::VisitGotoStmt(GotoStmt *Node) { |
| 329 | DumpStmt(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 330 | OS << " '" << Node->getLabel()->getName() |
| 331 | << "':" << (void*)Node->getLabel(); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 332 | } |
| 333 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 334 | //===----------------------------------------------------------------------===// |
| 335 | // Expr printing methods. |
| 336 | //===----------------------------------------------------------------------===// |
| 337 | |
| 338 | void StmtDumper::VisitExpr(Expr *Node) { |
| 339 | DumpExpr(Node); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 340 | } |
| 341 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 342 | static void DumpBasePath(raw_ostream &OS, CastExpr *Node) { |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 343 | if (Node->path_empty()) |
Anders Carlsson | 5cf86ba | 2010-04-24 19:06:50 +0000 | [diff] [blame] | 344 | return; |
| 345 | |
| 346 | OS << " ("; |
| 347 | bool First = true; |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 348 | for (CastExpr::path_iterator |
| 349 | I = Node->path_begin(), E = Node->path_end(); I != E; ++I) { |
Anders Carlsson | 5cf86ba | 2010-04-24 19:06:50 +0000 | [diff] [blame] | 350 | const CXXBaseSpecifier *Base = *I; |
| 351 | if (!First) |
| 352 | OS << " -> "; |
| 353 | |
| 354 | const CXXRecordDecl *RD = |
| 355 | cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); |
| 356 | |
| 357 | if (Base->isVirtual()) |
| 358 | OS << "virtual "; |
| 359 | OS << RD->getName(); |
| 360 | First = false; |
| 361 | } |
| 362 | |
| 363 | OS << ')'; |
| 364 | } |
| 365 | |
Anders Carlsson | 27a5b9b | 2009-08-22 23:33:40 +0000 | [diff] [blame] | 366 | void StmtDumper::VisitCastExpr(CastExpr *Node) { |
| 367 | DumpExpr(Node); |
Anders Carlsson | 5cf86ba | 2010-04-24 19:06:50 +0000 | [diff] [blame] | 368 | OS << " <" << Node->getCastKindName(); |
| 369 | DumpBasePath(OS, Node); |
| 370 | OS << ">"; |
Anders Carlsson | 27a5b9b | 2009-08-22 23:33:40 +0000 | [diff] [blame] | 371 | } |
| 372 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 373 | void StmtDumper::VisitDeclRefExpr(DeclRefExpr *Node) { |
| 374 | DumpExpr(Node); |
Ted Kremenek | eb641f9 | 2007-09-10 17:32:55 +0000 | [diff] [blame] | 375 | |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 376 | OS << " "; |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 377 | DumpDeclRef(Node->getDecl()); |
Chandler Carruth | 3aa8140 | 2011-05-01 23:48:14 +0000 | [diff] [blame] | 378 | if (Node->getDecl() != Node->getFoundDecl()) { |
| 379 | OS << " ("; |
| 380 | DumpDeclRef(Node->getFoundDecl()); |
| 381 | OS << ")"; |
| 382 | } |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 383 | } |
| 384 | |
| 385 | void StmtDumper::DumpDeclRef(Decl *d) { |
| 386 | OS << d->getDeclKindName() << ' ' << (void*) d; |
| 387 | |
| 388 | if (NamedDecl *nd = dyn_cast<NamedDecl>(d)) { |
| 389 | OS << " '"; |
| 390 | nd->getDeclName().printName(OS); |
| 391 | OS << "'"; |
Ted Kremenek | eb641f9 | 2007-09-10 17:32:55 +0000 | [diff] [blame] | 392 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 393 | |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 394 | if (ValueDecl *vd = dyn_cast<ValueDecl>(d)) { |
| 395 | OS << ' '; DumpType(vd->getType()); |
| 396 | } |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 397 | } |
| 398 | |
John McCall | 9d5f35e | 2009-12-11 21:50:11 +0000 | [diff] [blame] | 399 | void StmtDumper::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) { |
| 400 | DumpExpr(Node); |
| 401 | OS << " ("; |
| 402 | if (!Node->requiresADL()) OS << "no "; |
Benjamin Kramer | 900fc63 | 2010-04-17 09:33:03 +0000 | [diff] [blame] | 403 | OS << "ADL) = '" << Node->getName() << '\''; |
John McCall | 9d5f35e | 2009-12-11 21:50:11 +0000 | [diff] [blame] | 404 | |
| 405 | UnresolvedLookupExpr::decls_iterator |
| 406 | I = Node->decls_begin(), E = Node->decls_end(); |
| 407 | if (I == E) OS << " empty"; |
| 408 | for (; I != E; ++I) |
| 409 | OS << " " << (void*) *I; |
| 410 | } |
| 411 | |
Steve Naroff | 3c64d9e | 2008-03-12 13:19:12 +0000 | [diff] [blame] | 412 | void StmtDumper::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) { |
Steve Naroff | 466c2e3 | 2008-05-23 00:59:14 +0000 | [diff] [blame] | 413 | DumpExpr(Node); |
Steve Naroff | 3c64d9e | 2008-03-12 13:19:12 +0000 | [diff] [blame] | 414 | |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 415 | OS << " " << Node->getDecl()->getDeclKindName() |
Benjamin Kramer | b8989f2 | 2011-10-14 18:45:37 +0000 | [diff] [blame] | 416 | << "Decl='" << *Node->getDecl() |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 417 | << "' " << (void*)Node->getDecl(); |
Steve Naroff | 218543b | 2008-05-23 22:01:24 +0000 | [diff] [blame] | 418 | if (Node->isFreeIvar()) |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 419 | OS << " isFreeIvar"; |
Steve Naroff | 3c64d9e | 2008-03-12 13:19:12 +0000 | [diff] [blame] | 420 | } |
| 421 | |
Chris Lattner | d9f6910 | 2008-08-10 01:53:14 +0000 | [diff] [blame] | 422 | void StmtDumper::VisitPredefinedExpr(PredefinedExpr *Node) { |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 423 | DumpExpr(Node); |
| 424 | switch (Node->getIdentType()) { |
David Blaikie | b219cfc | 2011-09-23 05:06:16 +0000 | [diff] [blame] | 425 | default: llvm_unreachable("unknown case"); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 426 | case PredefinedExpr::Func: OS << " __func__"; break; |
| 427 | case PredefinedExpr::Function: OS << " __FUNCTION__"; break; |
Nico Weber | 28ad063 | 2012-06-23 02:07:59 +0000 | [diff] [blame] | 428 | case PredefinedExpr::LFunction: OS << " L__FUNCTION__"; break; |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 429 | case PredefinedExpr::PrettyFunction: OS << " __PRETTY_FUNCTION__";break; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 430 | } |
| 431 | } |
| 432 | |
| 433 | void StmtDumper::VisitCharacterLiteral(CharacterLiteral *Node) { |
Chris Lattner | a0df31a | 2007-08-09 01:04:32 +0000 | [diff] [blame] | 434 | DumpExpr(Node); |
Richard Trieu | 49cf884 | 2011-11-03 23:56:23 +0000 | [diff] [blame] | 435 | OS << " " << Node->getValue(); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 436 | } |
| 437 | |
| 438 | void StmtDumper::VisitIntegerLiteral(IntegerLiteral *Node) { |
| 439 | DumpExpr(Node); |
| 440 | |
| 441 | bool isSigned = Node->getType()->isSignedIntegerType(); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 442 | OS << " " << Node->getValue().toString(10, isSigned); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 443 | } |
| 444 | void StmtDumper::VisitFloatingLiteral(FloatingLiteral *Node) { |
| 445 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 446 | OS << " " << Node->getValueAsApproximateDouble(); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 447 | } |
Chris Lattner | 5d66145 | 2007-08-26 03:42:43 +0000 | [diff] [blame] | 448 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 449 | void StmtDumper::VisitStringLiteral(StringLiteral *Str) { |
Chris Lattner | a0df31a | 2007-08-09 01:04:32 +0000 | [diff] [blame] | 450 | DumpExpr(Str); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 451 | OS << " "; |
Richard Trieu | 8ab09da | 2012-06-13 20:25:24 +0000 | [diff] [blame] | 452 | Str->outputString(OS); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 453 | } |
Chris Lattner | 17a1a72 | 2007-08-30 01:00:35 +0000 | [diff] [blame] | 454 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 455 | void StmtDumper::VisitUnaryOperator(UnaryOperator *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 456 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 457 | OS << " " << (Node->isPostfix() ? "postfix" : "prefix") |
| 458 | << " '" << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'"; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 459 | } |
Peter Collingbourne | f4e3cfb | 2011-03-11 19:24:49 +0000 | [diff] [blame] | 460 | void StmtDumper::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 461 | DumpExpr(Node); |
Peter Collingbourne | f4e3cfb | 2011-03-11 19:24:49 +0000 | [diff] [blame] | 462 | switch(Node->getKind()) { |
| 463 | case UETT_SizeOf: |
| 464 | OS << " sizeof "; |
| 465 | break; |
| 466 | case UETT_AlignOf: |
Jordan Rose | f70a886 | 2012-06-30 21:33:57 +0000 | [diff] [blame] | 467 | OS << " alignof "; |
Peter Collingbourne | f4e3cfb | 2011-03-11 19:24:49 +0000 | [diff] [blame] | 468 | break; |
| 469 | case UETT_VecStep: |
| 470 | OS << " vec_step "; |
| 471 | break; |
| 472 | } |
Sebastian Redl | 0518999 | 2008-11-11 17:56:53 +0000 | [diff] [blame] | 473 | if (Node->isArgumentType()) |
| 474 | DumpType(Node->getArgumentType()); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 475 | } |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 476 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 477 | void StmtDumper::VisitMemberExpr(MemberExpr *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 478 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 479 | OS << " " << (Node->isArrow() ? "->" : ".") |
Benjamin Kramer | b8989f2 | 2011-10-14 18:45:37 +0000 | [diff] [blame] | 480 | << *Node->getMemberDecl() << ' ' |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 481 | << (void*)Node->getMemberDecl(); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 482 | } |
Nate Begeman | 213541a | 2008-04-18 23:10:10 +0000 | [diff] [blame] | 483 | void StmtDumper::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 484 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 485 | OS << " " << Node->getAccessor().getNameStart(); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 486 | } |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 487 | void StmtDumper::VisitBinaryOperator(BinaryOperator *Node) { |
| 488 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 489 | OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'"; |
Chris Lattner | eb14fe8 | 2007-08-25 02:00:02 +0000 | [diff] [blame] | 490 | } |
| 491 | void StmtDumper::VisitCompoundAssignOperator(CompoundAssignOperator *Node) { |
| 492 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 493 | OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) |
| 494 | << "' ComputeLHSTy="; |
Eli Friedman | ab3a852 | 2009-03-28 01:22:36 +0000 | [diff] [blame] | 495 | DumpType(Node->getComputationLHSType()); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 496 | OS << " ComputeResultTy="; |
Eli Friedman | ab3a852 | 2009-03-28 01:22:36 +0000 | [diff] [blame] | 497 | DumpType(Node->getComputationResultType()); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 498 | } |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 499 | |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 500 | void StmtDumper::VisitBlockExpr(BlockExpr *Node) { |
| 501 | DumpExpr(Node); |
| 502 | |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 503 | BlockDecl *block = Node->getBlockDecl(); |
John McCall | 89da8cf | 2012-03-10 03:04:55 +0000 | [diff] [blame] | 504 | OS << " decl=" << block; |
| 505 | |
| 506 | IndentLevel++; |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 507 | if (block->capturesCXXThis()) { |
| 508 | OS << '\n'; Indent(); OS << "(capture this)"; |
| 509 | } |
| 510 | for (BlockDecl::capture_iterator |
| 511 | i = block->capture_begin(), e = block->capture_end(); i != e; ++i) { |
| 512 | OS << '\n'; |
| 513 | Indent(); |
| 514 | OS << "(capture "; |
| 515 | if (i->isByRef()) OS << "byref "; |
| 516 | if (i->isNested()) OS << "nested "; |
Douglas Gregor | ac1303e | 2012-02-22 05:02:47 +0000 | [diff] [blame] | 517 | if (i->getVariable()) |
| 518 | DumpDeclRef(i->getVariable()); |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 519 | if (i->hasCopyExpr()) DumpSubTree(i->getCopyExpr()); |
| 520 | OS << ")"; |
| 521 | } |
| 522 | IndentLevel--; |
| 523 | |
John McCall | 89da8cf | 2012-03-10 03:04:55 +0000 | [diff] [blame] | 524 | OS << '\n'; |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 525 | DumpSubTree(block->getBody()); |
| 526 | } |
| 527 | |
John McCall | 4b9c2d2 | 2011-11-06 09:01:30 +0000 | [diff] [blame] | 528 | void StmtDumper::VisitOpaqueValueExpr(OpaqueValueExpr *Node) { |
| 529 | DumpExpr(Node); |
| 530 | |
| 531 | if (Expr *Source = Node->getSourceExpr()) { |
| 532 | OS << '\n'; |
| 533 | DumpSubTree(Source); |
| 534 | } |
| 535 | } |
| 536 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 537 | // GNU extensions. |
| 538 | |
| 539 | void StmtDumper::VisitAddrLabelExpr(AddrLabelExpr *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 540 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 541 | OS << " " << Node->getLabel()->getName() |
| 542 | << " " << (void*)Node->getLabel(); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 543 | } |
| 544 | |
Chris Lattner | f9e0581 | 2007-08-09 18:03:18 +0000 | [diff] [blame] | 545 | //===----------------------------------------------------------------------===// |
| 546 | // C++ Expressions |
| 547 | //===----------------------------------------------------------------------===// |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 548 | |
Douglas Gregor | 49badde | 2008-10-27 19:41:14 +0000 | [diff] [blame] | 549 | void StmtDumper::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 550 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 551 | OS << " " << Node->getCastName() |
| 552 | << "<" << Node->getTypeAsWritten().getAsString() << ">" |
Anders Carlsson | 5cf86ba | 2010-04-24 19:06:50 +0000 | [diff] [blame] | 553 | << " <" << Node->getCastKindName(); |
| 554 | DumpBasePath(OS, Node); |
| 555 | OS << ">"; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 556 | } |
| 557 | |
| 558 | void StmtDumper::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) { |
Chris Lattner | 13cb21f | 2007-08-09 17:35:30 +0000 | [diff] [blame] | 559 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 560 | OS << " " << (Node->getValue() ? "true" : "false"); |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 561 | } |
| 562 | |
Douglas Gregor | cd9b46e | 2008-11-04 14:56:14 +0000 | [diff] [blame] | 563 | void StmtDumper::VisitCXXThisExpr(CXXThisExpr *Node) { |
| 564 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 565 | OS << " this"; |
Douglas Gregor | cd9b46e | 2008-11-04 14:56:14 +0000 | [diff] [blame] | 566 | } |
| 567 | |
Douglas Gregor | 49badde | 2008-10-27 19:41:14 +0000 | [diff] [blame] | 568 | void StmtDumper::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) { |
| 569 | DumpExpr(Node); |
Eli Friedman | cc2fca2 | 2011-09-02 17:38:59 +0000 | [diff] [blame] | 570 | OS << " functional cast to " << Node->getTypeAsWritten().getAsString() |
| 571 | << " <" << Node->getCastKindName() << ">"; |
Douglas Gregor | 49badde | 2008-10-27 19:41:14 +0000 | [diff] [blame] | 572 | } |
| 573 | |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 574 | void StmtDumper::VisitCXXConstructExpr(CXXConstructExpr *Node) { |
| 575 | DumpExpr(Node); |
John McCall | d4bbdfe | 2010-02-02 19:03:45 +0000 | [diff] [blame] | 576 | CXXConstructorDecl *Ctor = Node->getConstructor(); |
| 577 | DumpType(Ctor->getType()); |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 578 | if (Node->isElidable()) |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 579 | OS << " elidable"; |
John McCall | f8cf0b0 | 2010-08-07 06:38:55 +0000 | [diff] [blame] | 580 | if (Node->requiresZeroInitialization()) |
| 581 | OS << " zeroing"; |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 582 | } |
| 583 | |
| 584 | void StmtDumper::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) { |
| 585 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 586 | OS << " "; |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 587 | DumpCXXTemporary(Node->getTemporary()); |
| 588 | } |
| 589 | |
John McCall | 4765fa0 | 2010-12-06 08:20:24 +0000 | [diff] [blame] | 590 | void StmtDumper::VisitExprWithCleanups(ExprWithCleanups *Node) { |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 591 | DumpExpr(Node); |
| 592 | ++IndentLevel; |
John McCall | 80ee6e8 | 2011-11-10 05:35:25 +0000 | [diff] [blame] | 593 | for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 594 | OS << "\n"; |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 595 | Indent(); |
John McCall | 80ee6e8 | 2011-11-10 05:35:25 +0000 | [diff] [blame] | 596 | OS << "(cleanup "; |
| 597 | DumpDeclRef(Node->getObject(i)); |
| 598 | OS << ")"; |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 599 | } |
| 600 | --IndentLevel; |
| 601 | } |
| 602 | |
| 603 | void StmtDumper::DumpCXXTemporary(CXXTemporary *Temporary) { |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 604 | OS << "(CXXTemporary " << (void *)Temporary << ")"; |
Anders Carlsson | 0eca1b6 | 2009-08-12 00:21:52 +0000 | [diff] [blame] | 605 | } |
| 606 | |
Anders Carlsson | 5508518 | 2007-08-21 17:43:55 +0000 | [diff] [blame] | 607 | //===----------------------------------------------------------------------===// |
| 608 | // Obj-C Expressions |
| 609 | //===----------------------------------------------------------------------===// |
| 610 | |
Ted Kremenek | b3d914b | 2008-02-29 22:04:05 +0000 | [diff] [blame] | 611 | void StmtDumper::VisitObjCMessageExpr(ObjCMessageExpr* Node) { |
| 612 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 613 | OS << " selector=" << Node->getSelector().getAsString(); |
Douglas Gregor | 04badcf | 2010-04-21 00:45:42 +0000 | [diff] [blame] | 614 | switch (Node->getReceiverKind()) { |
| 615 | case ObjCMessageExpr::Instance: |
| 616 | break; |
| 617 | |
| 618 | case ObjCMessageExpr::Class: |
| 619 | OS << " class="; |
| 620 | DumpType(Node->getClassReceiver()); |
| 621 | break; |
| 622 | |
| 623 | case ObjCMessageExpr::SuperInstance: |
| 624 | OS << " super (instance)"; |
| 625 | break; |
| 626 | |
| 627 | case ObjCMessageExpr::SuperClass: |
| 628 | OS << " super (class)"; |
| 629 | break; |
| 630 | } |
Ted Kremenek | b3d914b | 2008-02-29 22:04:05 +0000 | [diff] [blame] | 631 | } |
| 632 | |
Argyrios Kyrtzidis | 36faadd | 2012-05-10 20:02:31 +0000 | [diff] [blame] | 633 | void StmtDumper::VisitObjCBoxedExpr(ObjCBoxedExpr* Node) { |
| 634 | DumpExpr(Node); |
| 635 | OS << " selector=" << Node->getBoxingMethod()->getSelector().getAsString(); |
| 636 | } |
| 637 | |
Douglas Gregor | 8f5e3dd | 2010-04-23 22:50:49 +0000 | [diff] [blame] | 638 | void StmtDumper::VisitObjCAtCatchStmt(ObjCAtCatchStmt *Node) { |
| 639 | DumpStmt(Node); |
Douglas Gregor | c00d8e1 | 2010-04-26 16:46:50 +0000 | [diff] [blame] | 640 | if (VarDecl *CatchParam = Node->getCatchParamDecl()) { |
Douglas Gregor | 8f5e3dd | 2010-04-23 22:50:49 +0000 | [diff] [blame] | 641 | OS << " catch parm = "; |
| 642 | DumpDeclarator(CatchParam); |
| 643 | } else { |
| 644 | OS << " catch all"; |
| 645 | } |
| 646 | } |
| 647 | |
Anders Carlsson | f9bcf01 | 2007-08-22 15:14:15 +0000 | [diff] [blame] | 648 | void StmtDumper::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) { |
| 649 | DumpExpr(Node); |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 650 | OS << " "; |
Anders Carlsson | f9bcf01 | 2007-08-22 15:14:15 +0000 | [diff] [blame] | 651 | DumpType(Node->getEncodedType()); |
Anders Carlsson | f9bcf01 | 2007-08-22 15:14:15 +0000 | [diff] [blame] | 652 | } |
| 653 | |
Fariborz Jahanian | b62f681 | 2007-10-16 20:40:23 +0000 | [diff] [blame] | 654 | void StmtDumper::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) { |
| 655 | DumpExpr(Node); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 656 | |
Daniel Dunbar | 806c12e | 2009-12-03 09:13:13 +0000 | [diff] [blame] | 657 | OS << " " << Node->getSelector().getAsString(); |
Fariborz Jahanian | b62f681 | 2007-10-16 20:40:23 +0000 | [diff] [blame] | 658 | } |
| 659 | |
Fariborz Jahanian | 390d50a | 2007-10-17 16:58:11 +0000 | [diff] [blame] | 660 | void StmtDumper::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) { |
| 661 | DumpExpr(Node); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 662 | |
Benjamin Kramer | b8989f2 | 2011-10-14 18:45:37 +0000 | [diff] [blame] | 663 | OS << ' ' <<* Node->getProtocol(); |
Fariborz Jahanian | 390d50a | 2007-10-17 16:58:11 +0000 | [diff] [blame] | 664 | } |
Daniel Dunbar | 7f8ea5c | 2008-08-30 05:35:15 +0000 | [diff] [blame] | 665 | |
| 666 | void StmtDumper::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) { |
| 667 | DumpExpr(Node); |
John McCall | 12f78a6 | 2010-12-02 01:19:52 +0000 | [diff] [blame] | 668 | if (Node->isImplicitProperty()) { |
Fariborz Jahanian | 99130e5 | 2010-12-22 19:46:35 +0000 | [diff] [blame] | 669 | OS << " Kind=MethodRef Getter=\""; |
| 670 | if (Node->getImplicitPropertyGetter()) |
| 671 | OS << Node->getImplicitPropertyGetter()->getSelector().getAsString(); |
| 672 | else |
| 673 | OS << "(null)"; |
| 674 | |
| 675 | OS << "\" Setter=\""; |
John McCall | 12f78a6 | 2010-12-02 01:19:52 +0000 | [diff] [blame] | 676 | if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter()) |
| 677 | OS << Setter->getSelector().getAsString(); |
| 678 | else |
| 679 | OS << "(null)"; |
| 680 | OS << "\""; |
| 681 | } else { |
Benjamin Kramer | b8989f2 | 2011-10-14 18:45:37 +0000 | [diff] [blame] | 682 | OS << " Kind=PropertyRef Property=\"" << *Node->getExplicitProperty() <<'"'; |
John McCall | 12f78a6 | 2010-12-02 01:19:52 +0000 | [diff] [blame] | 683 | } |
Fariborz Jahanian | 5daf570 | 2008-11-22 18:39:36 +0000 | [diff] [blame] | 684 | |
Fariborz Jahanian | 8ac2d44 | 2010-10-14 16:04:05 +0000 | [diff] [blame] | 685 | if (Node->isSuperReceiver()) |
| 686 | OS << " super"; |
Argyrios Kyrtzidis | b085d89 | 2012-03-30 00:19:18 +0000 | [diff] [blame] | 687 | |
| 688 | OS << " Messaging="; |
| 689 | if (Node->isMessagingGetter() && Node->isMessagingSetter()) |
| 690 | OS << "Getter&Setter"; |
| 691 | else if (Node->isMessagingGetter()) |
| 692 | OS << "Getter"; |
| 693 | else if (Node->isMessagingSetter()) |
| 694 | OS << "Setter"; |
Douglas Gregor | cd9b46e | 2008-11-04 14:56:14 +0000 | [diff] [blame] | 695 | } |
| 696 | |
Ted Kremenek | ebcb57a | 2012-03-06 20:05:56 +0000 | [diff] [blame] | 697 | void StmtDumper::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *Node) { |
| 698 | DumpExpr(Node); |
| 699 | if (Node->isArraySubscriptRefExpr()) |
| 700 | OS << " Kind=ArraySubscript GetterForArray=\""; |
| 701 | else |
| 702 | OS << " Kind=DictionarySubscript GetterForDictionary=\""; |
| 703 | if (Node->getAtIndexMethodDecl()) |
| 704 | OS << Node->getAtIndexMethodDecl()->getSelector().getAsString(); |
| 705 | else |
| 706 | OS << "(null)"; |
| 707 | |
| 708 | if (Node->isArraySubscriptRefExpr()) |
| 709 | OS << "\" SetterForArray=\""; |
| 710 | else |
| 711 | OS << "\" SetterForDictionary=\""; |
| 712 | if (Node->setAtIndexMethodDecl()) |
| 713 | OS << Node->setAtIndexMethodDecl()->getSelector().getAsString(); |
| 714 | else |
| 715 | OS << "(null)"; |
| 716 | } |
| 717 | |
| 718 | void StmtDumper::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Node) { |
| 719 | DumpExpr(Node); |
| 720 | OS << " " << (Node->getValue() ? "__objc_yes" : "__objc_no"); |
| 721 | } |
| 722 | |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 723 | //===----------------------------------------------------------------------===// |
| 724 | // Stmt method implementations |
| 725 | //===----------------------------------------------------------------------===// |
| 726 | |
| 727 | /// dump - This does a local dump of the specified AST fragment. It dumps the |
| 728 | /// specified node and a few nodes underneath it, but not the whole subtree. |
| 729 | /// This is useful in a debugger. |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 730 | void Stmt::dump(SourceManager &SM) const { |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 731 | dump(llvm::errs(), SM); |
| 732 | } |
| 733 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 734 | void Stmt::dump(raw_ostream &OS, SourceManager &SM) const { |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 735 | StmtDumper P(&SM, OS, 4); |
Chris Lattner | b393879 | 2007-08-30 00:53:54 +0000 | [diff] [blame] | 736 | P.DumpSubTree(const_cast<Stmt*>(this)); |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 737 | OS << "\n"; |
Chris Lattner | 0c727a3 | 2007-08-30 00:40:08 +0000 | [diff] [blame] | 738 | } |
| 739 | |
| 740 | /// dump - This does a local dump of the specified AST fragment. It dumps the |
| 741 | /// specified node and a few nodes underneath it, but not the whole subtree. |
| 742 | /// This is useful in a debugger. |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 743 | void Stmt::dump() const { |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 744 | StmtDumper P(0, llvm::errs(), 4); |
Chris Lattner | b393879 | 2007-08-30 00:53:54 +0000 | [diff] [blame] | 745 | P.DumpSubTree(const_cast<Stmt*>(this)); |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 746 | llvm::errs() << "\n"; |
Chris Lattner | 0c727a3 | 2007-08-30 00:40:08 +0000 | [diff] [blame] | 747 | } |
| 748 | |
| 749 | /// dumpAll - This does a dump of the specified AST fragment and all subtrees. |
Chris Lattner | e300c87 | 2007-08-30 06:17:34 +0000 | [diff] [blame] | 750 | void Stmt::dumpAll(SourceManager &SM) const { |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 751 | StmtDumper P(&SM, llvm::errs(), ~0U); |
Chris Lattner | b393879 | 2007-08-30 00:53:54 +0000 | [diff] [blame] | 752 | P.DumpSubTree(const_cast<Stmt*>(this)); |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 753 | llvm::errs() << "\n"; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 754 | } |
| 755 | |
| 756 | /// dumpAll - This does a dump of the specified AST fragment and all subtrees. |
| 757 | void Stmt::dumpAll() const { |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 758 | StmtDumper P(0, llvm::errs(), ~0U); |
Chris Lattner | b393879 | 2007-08-30 00:53:54 +0000 | [diff] [blame] | 759 | P.DumpSubTree(const_cast<Stmt*>(this)); |
Argyrios Kyrtzidis | 9668033 | 2010-08-09 10:54:31 +0000 | [diff] [blame] | 760 | llvm::errs() << "\n"; |
Chris Lattner | 6000dac | 2007-08-08 22:51:59 +0000 | [diff] [blame] | 761 | } |