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