 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
71.0% |
277 / 390 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
89.2% |
348 / 390 |
| |
|
Line Coverage: |
79.4% |
432 / 544 |
| |
 |
|
 |
1 : //===--- DeclPrinter.cpp - Printing implementation for Decl 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 Decl::dump method, which pretty print the
11 : // AST back out to C/Objective-C/C++/Objective-C++ code.
12 : //
13 : //===----------------------------------------------------------------------===//
14 : #include "clang/AST/ASTContext.h"
15 : #include "clang/AST/DeclVisitor.h"
16 : #include "clang/AST/Decl.h"
17 : #include "clang/AST/DeclCXX.h"
18 : #include "clang/AST/DeclObjC.h"
19 : #include "clang/AST/Expr.h"
20 : #include "clang/AST/ExprCXX.h"
21 : #include "clang/AST/PrettyPrinter.h"
22 : #include "llvm/Support/raw_ostream.h"
23 : using namespace clang;
24 :
25 : namespace {
26 : class DeclPrinter : public DeclVisitor<DeclPrinter> {
27 : llvm::raw_ostream &Out;
28 : ASTContext &Context;
29 : PrintingPolicy Policy;
30 : unsigned Indentation;
31 :
32 407: llvm::raw_ostream& Indent() { return Indent(Indentation); }
33 : llvm::raw_ostream& Indent(unsigned Indentation);
34 : void ProcessDeclGroup(llvm::SmallVectorImpl<Decl*>& Decls);
35 :
36 : void Print(AccessSpecifier AS);
37 :
38 : public:
39 : DeclPrinter(llvm::raw_ostream &Out, ASTContext &Context,
40 : const PrintingPolicy &Policy,
41 202: unsigned Indentation = 0)
42 202: : Out(Out), Context(Context), Policy(Policy), Indentation(Indentation) { }
43 :
44 : void VisitDeclContext(DeclContext *DC, bool Indent = true);
45 :
46 : void VisitTranslationUnitDecl(TranslationUnitDecl *D);
47 : void VisitTypedefDecl(TypedefDecl *D);
48 : void VisitEnumDecl(EnumDecl *D);
49 : void VisitRecordDecl(RecordDecl *D);
50 : void VisitEnumConstantDecl(EnumConstantDecl *D);
51 : void VisitFunctionDecl(FunctionDecl *D);
52 : void VisitFieldDecl(FieldDecl *D);
53 : void VisitVarDecl(VarDecl *D);
54 : void VisitParmVarDecl(ParmVarDecl *D);
55 : void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
56 : void VisitNamespaceDecl(NamespaceDecl *D);
57 : void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
58 : void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
59 : void VisitCXXRecordDecl(CXXRecordDecl *D);
60 : void VisitLinkageSpecDecl(LinkageSpecDecl *D);
61 : void VisitTemplateDecl(TemplateDecl *D);
62 : void VisitObjCMethodDecl(ObjCMethodDecl *D);
63 : void VisitObjCClassDecl(ObjCClassDecl *D);
64 : void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
65 : void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
66 : void VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D);
67 : void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
68 : void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
69 : void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
70 : void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
71 : void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
72 : void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
73 : void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
74 : void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
75 : void VisitUsingDecl(UsingDecl *D);
76 : void VisitUsingShadowDecl(UsingShadowDecl *D);
77 : };
78 : }
79 :
80 0: void Decl::print(llvm::raw_ostream &Out, unsigned Indentation) const {
81 0: print(Out, getASTContext().PrintingPolicy, Indentation);
82 0: }
83 :
84 : void Decl::print(llvm::raw_ostream &Out, const PrintingPolicy &Policy,
85 107: unsigned Indentation) const {
86 107: DeclPrinter Printer(Out, getASTContext(), Policy, Indentation);
87 107: Printer.Visit(const_cast<Decl*>(this));
88 107: }
89 :
90 0: static QualType GetBaseType(QualType T) {
91 : // FIXME: This should be on the Type class!
92 0: QualType BaseType = T;
0: branch 2 not taken
0: branch 3 not taken
93 0: while (!BaseType->isSpecifierType()) {
0: branch 1 not taken
0: branch 2 not taken
94 0: if (isa<TypedefType>(BaseType))
95 0: break;
0: branch 2 not taken
0: branch 3 not taken
96 0: else if (const PointerType* PTy = BaseType->getAs<PointerType>())
97 0: BaseType = PTy->getPointeeType();
0: branch 1 not taken
0: branch 2 not taken
98 0: else if (const ArrayType* ATy = dyn_cast<ArrayType>(BaseType))
99 0: BaseType = ATy->getElementType();
0: branch 2 not taken
0: branch 3 not taken
100 0: else if (const FunctionType* FTy = BaseType->getAs<FunctionType>())
101 0: BaseType = FTy->getResultType();
0: branch 2 not taken
0: branch 3 not taken
102 0: else if (const VectorType *VTy = BaseType->getAs<VectorType>())
103 0: BaseType = VTy->getElementType();
104 : else
105 0: assert(0 && "Unknown declarator!");
106 : }
107 : return BaseType;
108 : }
109 :
110 353: static QualType getDeclType(Decl* D) {
47: branch 1 taken
306: branch 2 taken
111 353: if (TypedefDecl* TDD = dyn_cast<TypedefDecl>(D))
112 47: return TDD->getUnderlyingType();
166: branch 1 taken
140: branch 2 taken
113 306: if (ValueDecl* VD = dyn_cast<ValueDecl>(D))
114 166: return VD->getType();
115 140: return QualType();
116 : }
117 :
118 : void Decl::printGroup(Decl** Begin, unsigned NumDecls,
119 : llvm::raw_ostream &Out, const PrintingPolicy &Policy,
120 72: unsigned Indentation) {
66: branch 0 taken
6: branch 1 taken
121 72: if (NumDecls == 1) {
122 66: (*Begin)->print(Out, Policy, Indentation);
123 66: return;
124 : }
125 :
126 6: Decl** End = Begin + NumDecls;
127 6: TagDecl* TD = dyn_cast<TagDecl>(*Begin);
3: branch 0 taken
3: branch 1 taken
128 6: if (TD)
129 3: ++Begin;
130 :
131 6: PrintingPolicy SubPolicy(Policy);
3: branch 0 taken
3: branch 1 taken
3: branch 3 taken
0: branch 4 not taken
3: branch 5 taken
3: branch 6 taken
132 6: if (TD && TD->isDefinition()) {
133 3: TD->print(Out, Policy, Indentation);
134 3: Out << " ";
135 3: SubPolicy.SuppressTag = true;
136 : }
137 :
138 6: bool isFirst = true;
14: branch 0 taken
6: branch 1 taken
139 20: for ( ; Begin != End; ++Begin) {
6: branch 0 taken
8: branch 1 taken
140 14: if (isFirst) {
141 6: SubPolicy.SuppressSpecifiers = false;
142 6: isFirst = false;
143 : } else {
8: branch 0 taken
0: branch 1 not taken
144 8: if (!isFirst) Out << ", ";
145 8: SubPolicy.SuppressSpecifiers = true;
146 : }
147 :
148 14: (*Begin)->print(Out, SubPolicy, Indentation);
149 : }
150 : }
151 :
152 0: void DeclContext::dumpDeclContext() const {
153 : // Get the translation unit
154 0: const DeclContext *DC = this;
0: branch 1 not taken
0: branch 2 not taken
155 0: while (!DC->isTranslationUnit())
156 0: DC = DC->getParent();
157 :
158 0: ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext();
159 0: DeclPrinter Printer(llvm::errs(), Ctx, Ctx.PrintingPolicy, 0);
160 0: Printer.VisitDeclContext(const_cast<DeclContext *>(this), /*Indent=*/false);
161 0: }
162 :
163 0: void Decl::dump() const {
164 0: print(llvm::errs());
165 0: }
166 :
167 417: llvm::raw_ostream& DeclPrinter::Indent(unsigned Indentation) {
222: branch 0 taken
417: branch 1 taken
168 639: for (unsigned i = 0; i != Indentation; ++i)
169 222: Out << " ";
170 417: return Out;
171 : }
172 :
173 1: void DeclPrinter::ProcessDeclGroup(llvm::SmallVectorImpl<Decl*>& Decls) {
174 1: this->Indent();
175 1: Decl::printGroup(Decls.data(), Decls.size(), Out, Policy, Indentation);
176 1: Out << ";\n";
177 1: Decls.clear();
178 :
179 1: }
180 :
181 12: void DeclPrinter::Print(AccessSpecifier AS) {
0: branch 0 not taken
12: branch 1 taken
0: branch 2 not taken
0: branch 3 not taken
0: branch 4 not taken
182 12: switch(AS) {
183 0: case AS_none: assert(0 && "No access specifier!"); break;
184 12: case AS_public: Out << "public"; break;
185 0: case AS_protected: Out << "protected"; break;
186 0: case AS_private: Out << " private"; break;
187 : }
188 12: }
189 :
190 : //----------------------------------------------------------------------------
191 : // Common C declarations
192 : //----------------------------------------------------------------------------
193 :
194 91: void DeclPrinter::VisitDeclContext(DeclContext *DC, bool Indent) {
38: branch 0 taken
53: branch 1 taken
195 91: if (Indent)
196 38: Indentation += Policy.Indentation;
197 :
198 91: bool PrintAccess = isa<CXXRecordDecl>(DC);
199 91: AccessSpecifier CurAS = AS_none;
200 :
201 91: llvm::SmallVector<Decl*, 2> Decls;
404: branch 4 taken
91: branch 5 taken
202 495: for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end();
203 : D != DEnd; ++D) {
267: branch 0 taken
137: branch 1 taken
204 404: if (!Policy.Dump) {
205 : // Skip over implicit declarations in pretty-printing mode.
233: branch 2 taken
34: branch 3 taken
206 267: if (D->isImplicit()) continue;
207 : // FIXME: Ugly hack so we don't pretty-print the builtin declaration
208 : // of __builtin_va_list. There should be some other way to check that.
226: branch 2 taken
7: branch 3 taken
17: branch 8 taken
209: branch 9 taken
226: branch 10 taken
7: branch 11 taken
17: branch 13 taken
216: branch 14 taken
209 233: if (isa<NamedDecl>(*D) && cast<NamedDecl>(*D)->getNameAsString() ==
210 : "__builtin_va_list")
211 17: continue;
212 : }
213 :
36: branch 0 taken
317: branch 1 taken
214 353: if (PrintAccess) {
215 36: AccessSpecifier AS = D->getAccess();
216 :
10: branch 0 taken
26: branch 1 taken
217 36: if (AS != CurAS) {
10: branch 0 taken
0: branch 1 not taken
218 10: if (Indent)
219 10: this->Indent(Indentation - Policy.Indentation);
220 10: Print(AS);
221 10: Out << ":\n";
222 10: CurAS = AS;
223 : }
224 : }
225 :
226 : // The next bits of code handles stuff like "struct {int x;} a,b"; we're
227 : // forced to merge the declarations because there's no other way to
228 : // refer to the struct in question. This limited merging is safe without
229 : // a bunch of other checks because it only merges declarations directly
230 : // referring to the tag, not typedefs.
231 : //
232 : // Check whether the current declaration should be grouped with a previous
233 : // unnamed struct.
234 353: QualType CurDeclType = getDeclType(*D);
0: branch 1 not taken
353: branch 2 taken
0: branch 4 not taken
0: branch 5 not taken
0: branch 6 not taken
353: branch 7 taken
235 353: if (!Decls.empty() && !CurDeclType.isNull()) {
236 0: QualType BaseType = GetBaseType(CurDeclType);
0: branch 1 not taken
0: branch 2 not taken
0: branch 4 not taken
0: branch 5 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 11 not taken
0: branch 12 not taken
237 0: if (!BaseType.isNull() && isa<TagType>(BaseType) &&
238 : cast<TagType>(BaseType)->getDecl() == Decls[0]) {
239 0: Decls.push_back(*D);
240 0: continue;
241 : }
242 : }
243 :
244 : // If we have a merged group waiting to be handled, handle it now.
0: branch 1 not taken
353: branch 2 taken
245 353: if (!Decls.empty())
246 0: ProcessDeclGroup(Decls);
247 :
248 : // If the current declaration is an unnamed tag type, save it
249 : // so we can merge it with the subsequent declaration(s) using it.
34: branch 2 taken
319: branch 3 taken
1: branch 7 taken
33: branch 8 taken
1: branch 9 taken
352: branch 10 taken
250 353: if (isa<TagDecl>(*D) && !cast<TagDecl>(*D)->getIdentifier()) {
251 1: Decls.push_back(*D);
252 1: continue;
253 : }
254 352: this->Indent();
255 352: Visit(*D);
256 :
257 : // FIXME: Need to be able to tell the DeclPrinter when
258 352: const char *Terminator = 0;
107: branch 2 taken
245: branch 3 taken
67: branch 7 taken
40: branch 8 taken
67: branch 9 taken
285: branch 10 taken
259 352: if (isa<FunctionDecl>(*D) &&
260 : cast<FunctionDecl>(*D)->isThisDeclarationADefinition())
261 67: Terminator = 0;
33: branch 2 taken
252: branch 3 taken
7: branch 7 taken
26: branch 8 taken
7: branch 9 taken
278: branch 10 taken
262 285: else if (isa<ObjCMethodDecl>(*D) && cast<ObjCMethodDecl>(*D)->getBody())
263 7: Terminator = 0;
271: branch 2 taken
7: branch 3 taken
271: branch 6 taken
0: branch 7 not taken
266: branch 10 taken
5: branch 11 taken
253: branch 14 taken
13: branch 15 taken
244: branch 18 taken
9: branch 19 taken
242: branch 22 taken
2: branch 23 taken
2: branch 26 taken
240: branch 27 taken
38: branch 28 taken
240: branch 29 taken
264 278: else if (isa<NamespaceDecl>(*D) || isa<LinkageSpecDecl>(*D) ||
265 : isa<ObjCImplementationDecl>(*D) ||
266 : isa<ObjCInterfaceDecl>(*D) ||
267 : isa<ObjCProtocolDecl>(*D) ||
268 : isa<ObjCCategoryImplDecl>(*D) ||
269 : isa<ObjCCategoryDecl>(*D))
270 38: Terminator = 0;
3: branch 2 taken
237: branch 3 taken
271 240: else if (isa<EnumConstantDecl>(*D)) {
272 3: DeclContext::decl_iterator Next = D;
273 3: ++Next;
0: branch 1 not taken
3: branch 2 taken
274 3: if (Next != DEnd)
275 0: Terminator = ",";
276 : } else
277 237: Terminator = ";";
278 :
237: branch 0 taken
115: branch 1 taken
279 352: if (Terminator)
280 237: Out << Terminator;
281 352: Out << "\n";
282 : }
283 :
1: branch 1 taken
90: branch 2 taken
284 91: if (!Decls.empty())
285 1: ProcessDeclGroup(Decls);
286 :
38: branch 0 taken
53: branch 1 taken
287 91: if (Indent)
288 38: Indentation -= Policy.Indentation;
289 91: }
290 :
291 22: void DeclPrinter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
22: branch 0 taken
0: branch 1 not taken
292 22: VisitDeclContext(D, false);
293 22: }
294 :
295 47: void DeclPrinter::VisitTypedefDecl(TypedefDecl *D) {
296 47: std::string S = D->getNameAsString();
297 47: D->getUnderlyingType().getAsStringInternal(S, Policy);
47: branch 0 taken
0: branch 1 not taken
298 47: if (!Policy.SuppressSpecifiers)
299 47: Out << "typedef ";
300 47: Out << S;
301 47: }
302 :
303 3: void DeclPrinter::VisitEnumDecl(EnumDecl *D) {
304 3: Out << "enum " << D->getNameAsString() << " {\n";
3: branch 0 taken
0: branch 1 not taken
305 3: VisitDeclContext(D);
306 3: Indent() << "}";
307 3: }
308 :
309 17: void DeclPrinter::VisitRecordDecl(RecordDecl *D) {
310 17: Out << D->getKindName();
15: branch 1 taken
2: branch 2 taken
311 17: if (D->getIdentifier()) {
312 15: Out << " ";
313 15: Out << D->getNameAsString();
314 : }
315 :
15: branch 1 taken
2: branch 2 taken
316 17: if (D->isDefinition()) {
317 15: Out << " {\n";
15: branch 0 taken
0: branch 1 not taken
318 15: VisitDeclContext(D);
319 15: Indent() << "}";
320 : }
321 17: }
322 :
323 3: void DeclPrinter::VisitEnumConstantDecl(EnumConstantDecl *D) {
324 3: Out << D->getNameAsString();
0: branch 1 not taken
3: branch 2 taken
325 3: if (Expr *Init = D->getInitExpr()) {
326 0: Out << " = ";
327 0: Init->printPretty(Out, Context, 0, Policy, Indentation);
328 : }
329 3: }
330 :
331 112: void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) {
110: branch 0 taken
2: branch 1 taken
332 112: if (!Policy.SuppressSpecifiers) {
100: branch 1 taken
8: branch 2 taken
2: branch 3 taken
0: branch 4 not taken
0: branch 5 not taken
333 110: switch (D->getStorageClass()) {
334 100: case FunctionDecl::None: break;
335 8: case FunctionDecl::Extern: Out << "extern "; break;
336 2: case FunctionDecl::Static: Out << "static "; break;
337 0: case FunctionDecl::PrivateExtern: Out << "__private_extern__ "; break;
338 : }
339 :
26: branch 1 taken
84: branch 2 taken
340 110: if (D->isInlineSpecified()) Out << "inline ";
2: branch 1 taken
108: branch 2 taken
341 110: if (D->isVirtualAsWritten()) Out << "virtual ";
342 : }
343 :
344 112: PrintingPolicy SubPolicy(Policy);
345 112: SubPolicy.SuppressSpecifiers = false;
346 112: std::string Proto = D->getNameAsString();
110: branch 3 taken
2: branch 4 taken
347 112: if (isa<FunctionType>(D->getType().getTypePtr())) {
348 110: const FunctionType *AFT = D->getType()->getAs<FunctionType>();
349 :
350 110: const FunctionProtoType *FT = 0;
93: branch 1 taken
17: branch 2 taken
351 110: if (D->hasWrittenPrototype())
352 93: FT = dyn_cast<FunctionProtoType>(AFT);
353 :
354 110: Proto += "(";
91: branch 0 taken
19: branch 1 taken
355 110: if (FT) {
356 91: llvm::raw_string_ostream POut(Proto);
357 91: DeclPrinter ParamPrinter(POut, Context, SubPolicy, Indentation);
50: branch 1 taken
91: branch 2 taken
358 141: for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) {
9: branch 0 taken
41: branch 1 taken
359 50: if (i) POut << ", ";
360 50: ParamPrinter.VisitParmVarDecl(D->getParamDecl(i));
361 : }
362 :
2: branch 1 taken
89: branch 2 taken
363 91: if (FT->isVariadic()) {
2: branch 1 taken
0: branch 2 not taken
364 2: if (D->getNumParams()) POut << ", ";
365 2: POut << "...";
366 91: }
17: branch 1 taken
2: branch 2 taken
17: branch 4 taken
0: branch 5 not taken
17: branch 6 taken
2: branch 7 taken
367 19: } else if (D->isThisDeclarationADefinition() && !D->hasPrototype()) {
4: branch 1 taken
17: branch 2 taken
368 21: for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) {
0: branch 0 not taken
4: branch 1 taken
369 4: if (i)
370 0: Proto += ", ";
371 4: Proto += D->getParamDecl(i)->getNameAsString();
372 : }
373 : }
374 :
375 110: Proto += ")";
376 :
91: branch 0 taken
19: branch 1 taken
0: branch 3 not taken
91: branch 4 taken
0: branch 5 not taken
110: branch 6 taken
377 110: if (FT && FT->hasExceptionSpec()) {
378 0: Proto += " throw(";
0: branch 1 not taken
0: branch 2 not taken
379 0: if (FT->hasAnyExceptionSpec())
380 0: Proto += "...";
381 : else
0: branch 2 not taken
0: branch 3 not taken
382 0: for (unsigned I = 0, N = FT->getNumExceptions(); I != N; ++I) {
0: branch 0 not taken
0: branch 1 not taken
383 0: if (I)
384 0: Proto += ", ";
385 :
386 :
387 0: std::string ExceptionType;
388 0: FT->getExceptionType(I).getAsStringInternal(ExceptionType, SubPolicy);
389 0: Proto += ExceptionType;
390 : }
391 0: Proto += ")";
392 : }
393 :
0: branch 1 not taken
110: branch 2 taken
394 110: if (D->hasAttr<NoReturnAttr>())
395 0: Proto += " __attribute((noreturn))";
12: branch 1 taken
98: branch 2 taken
396 110: if (CXXConstructorDecl *CDecl = dyn_cast<CXXConstructorDecl>(D)) {
1: branch 1 taken
11: branch 2 taken
397 12: if (CDecl->getNumBaseOrMemberInitializers() > 0) {
398 1: Proto += " : ";
399 1: Out << Proto;
400 1: Proto.clear();
1: branch 1 taken
1: branch 2 taken
401 3: for (CXXConstructorDecl::init_const_iterator B = CDecl->init_begin(),
402 1: E = CDecl->init_end();
403 : B != E; ++B) {
404 1: CXXBaseOrMemberInitializer * BMInitializer = (*B);
0: branch 1 not taken
1: branch 2 taken
405 1: if (B != CDecl->init_begin())
406 0: Out << ", ";
0: branch 1 not taken
1: branch 2 taken
407 1: if (BMInitializer->isMemberInitializer()) {
408 0: FieldDecl *FD = BMInitializer->getMember();
409 0: Out << FD->getNameAsString();
410 : } else {
411 1: Out << QualType(BMInitializer->getBaseClass(), 0).getAsString();
412 : }
413 :
414 1: Out << "(";
1: branch 1 taken
0: branch 2 not taken
415 1: if (!BMInitializer->getInit()) {
416 : // Nothing to print
417 : } else {
418 1: Expr *Init = BMInitializer->getInit();
0: branch 0 not taken
1: branch 1 taken
419 1: if (CXXExprWithTemporaries *Tmp
420 1: = dyn_cast<CXXExprWithTemporaries>(Init))
421 0: Init = Tmp->getSubExpr();
422 :
423 1: Init = Init->IgnoreParens();
424 :
425 1: Expr *SimpleInit = 0;
426 1: Expr **Args = 0;
427 1: unsigned NumArgs = 0;
0: branch 1 not taken
1: branch 2 taken
428 1: if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
429 0: Args = ParenList->getExprs();
430 0: NumArgs = ParenList->getNumExprs();
1: branch 0 taken
0: branch 1 not taken
431 1: } else if (CXXConstructExpr *Construct
432 1: = dyn_cast<CXXConstructExpr>(Init)) {
433 1: Args = Construct->getArgs();
434 1: NumArgs = Construct->getNumArgs();
435 : } else
436 0: SimpleInit = Init;
437 :
0: branch 0 not taken
1: branch 1 taken
438 1: if (SimpleInit)
439 0: SimpleInit->printPretty(Out, Context, 0, Policy, Indentation);
440 : else {
0: branch 0 not taken
1: branch 1 taken
441 1: for (unsigned I = 0; I != NumArgs; ++I) {
0: branch 1 not taken
0: branch 2 not taken
442 0: if (isa<CXXDefaultArgExpr>(Args[I]))
443 0: break;
444 :
0: branch 0 not taken
0: branch 1 not taken
445 0: if (I)
446 0: Out << ", ";
447 0: Args[I]->printPretty(Out, Context, 0, Policy, Indentation);
448 : }
449 : }
450 : }
451 1: Out << ")";
452 : }
453 : }
454 : }
455 : else
456 98: AFT->getResultType().getAsStringInternal(Proto, Policy);
457 : } else {
458 2: D->getType().getAsStringInternal(Proto, Policy);
459 : }
460 :
461 112: Out << Proto;
462 :
0: branch 1 not taken
112: branch 2 taken
463 112: if (D->isPure())
464 0: Out << " = 0";
0: branch 1 not taken
112: branch 2 taken
465 112: else if (D->isDeleted())
466 0: Out << " = delete";
67: branch 1 taken
45: branch 2 taken
467 112: else if (D->isThisDeclarationADefinition()) {
17: branch 1 taken
50: branch 2 taken
4: branch 4 taken
13: branch 5 taken
4: branch 6 taken
63: branch 7 taken
468 67: if (!D->hasPrototype() && D->getNumParams()) {
469 : // This is a K&R function definition, so we need to print the
470 : // parameters.
471 4: Out << '\n';
472 4: DeclPrinter ParamPrinter(Out, Context, SubPolicy, Indentation);
473 4: Indentation += Policy.Indentation;
4: branch 1 taken
4: branch 2 taken
474 8: for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) {
475 4: Indent();
476 4: ParamPrinter.VisitParmVarDecl(D->getParamDecl(i));
477 4: Out << ";\n";
478 : }
479 4: Indentation -= Policy.Indentation;
480 : } else
481 63: Out << ' ';
482 :
483 67: D->getBody()->printPretty(Out, Context, 0, SubPolicy, Indentation);
484 67: Out << '\n';
485 112: }
486 112: }
487 :
488 37: void DeclPrinter::VisitFieldDecl(FieldDecl *D) {
37: branch 0 taken
0: branch 1 not taken
0: branch 3 not taken
37: branch 4 taken
0: branch 5 not taken
37: branch 6 taken
489 37: if (!Policy.SuppressSpecifiers && D->isMutable())
490 0: Out << "mutable ";
491 :
492 37: std::string Name = D->getNameAsString();
493 37: D->getType().getAsStringInternal(Name, Policy);
494 37: Out << Name;
495 :
0: branch 1 not taken
37: branch 2 taken
496 37: if (D->isBitField()) {
497 0: Out << " : ";
498 0: D->getBitWidth()->printPretty(Out, Context, 0, Policy, Indentation);
499 37: }
500 37: }
501 :
502 150: void DeclPrinter::VisitVarDecl(VarDecl *D) {
144: branch 0 taken
6: branch 1 taken
1: branch 3 taken
143: branch 4 taken
1: branch 5 taken
149: branch 6 taken
503 150: if (!Policy.SuppressSpecifiers && D->getStorageClass() != VarDecl::None)
504 1: Out << VarDecl::getStorageClassSpecifierString(D->getStorageClass()) << " ";
505 :
144: branch 0 taken
6: branch 1 taken
0: branch 3 not taken
144: branch 4 taken
0: branch 5 not taken
150: branch 6 taken
506 150: if (!Policy.SuppressSpecifiers && D->isThreadSpecified())
507 0: Out << "__thread ";
508 :
509 150: std::string Name = D->getNameAsString();
510 150: QualType T = D->getType();
56: branch 1 taken
94: branch 2 taken
511 150: if (ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D))
512 56: T = Parm->getOriginalType();
513 150: T.getAsStringInternal(Name, Policy);
514 150: Out << Name;
46: branch 1 taken
104: branch 2 taken
515 150: if (D->getInit()) {
0: branch 1 not taken
46: branch 2 taken
516 46: if (D->hasCXXDirectInitializer())
517 0: Out << "(";
518 : else
519 46: Out << " = ";
520 46: D->getInit()->printPretty(Out, Context, 0, Policy, Indentation);
0: branch 1 not taken
46: branch 2 taken
521 46: if (D->hasCXXDirectInitializer())
522 0: Out << ")";
523 150: }
524 150: }
525 :
526 56: void DeclPrinter::VisitParmVarDecl(ParmVarDecl *D) {
527 56: VisitVarDecl(D);
528 56: }
529 :
530 2: void DeclPrinter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
531 2: Out << "__asm (";
532 2: D->getAsmString()->printPretty(Out, Context, 0, Policy, Indentation);
533 2: Out << ")";
534 2: }
535 :
536 : //----------------------------------------------------------------------------
537 : // C++ declarations
538 : //----------------------------------------------------------------------------
539 7: void DeclPrinter::VisitNamespaceDecl(NamespaceDecl *D) {
540 7: Out << "namespace " << D->getNameAsString() << " {\n";
7: branch 0 taken
0: branch 1 not taken
541 7: VisitDeclContext(D);
542 7: Indent() << "}";
543 7: }
544 :
545 4: void DeclPrinter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
546 4: Out << "using namespace ";
2: branch 1 taken
2: branch 2 taken
547 4: if (D->getQualifier())
548 2: D->getQualifier()->print(Out, Policy);
549 4: Out << D->getNominatedNamespaceAsWritten()->getNameAsString();
550 4: }
551 :
552 2: void DeclPrinter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
553 2: Out << "namespace " << D->getNameAsString() << " = ";
2: branch 1 taken
0: branch 2 not taken
554 2: if (D->getQualifier())
555 2: D->getQualifier()->print(Out, Policy);
556 2: Out << D->getAliasedNamespace()->getNameAsString();
557 2: }
558 :
559 19: void DeclPrinter::VisitCXXRecordDecl(CXXRecordDecl *D) {
560 19: Out << D->getKindName();
19: branch 1 taken
0: branch 2 not taken
561 19: if (D->getIdentifier()) {
562 19: Out << " ";
563 19: Out << D->getNameAsString();
564 : }
565 :
13: branch 1 taken
6: branch 2 taken
566 19: if (D->isDefinition()) {
567 : // Print the base classes
3: branch 1 taken
10: branch 2 taken
568 13: if (D->getNumBases()) {
569 3: Out << " : ";
5: branch 1 taken
3: branch 2 taken
570 11: for (CXXRecordDecl::base_class_iterator Base = D->bases_begin(),
571 3: BaseEnd = D->bases_end(); Base != BaseEnd; ++Base) {
2: branch 1 taken
3: branch 2 taken
572 5: if (Base != D->bases_begin())
573 2: Out << ", ";
574 :
2: branch 1 taken
3: branch 2 taken
575 5: if (Base->isVirtual())
576 2: Out << "virtual ";
577 :
578 5: AccessSpecifier AS = Base->getAccessSpecifierAsWritten();
2: branch 0 taken
3: branch 1 taken
579 5: if (AS != AS_none)
580 2: Print(AS);
581 5: Out << " " << Base->getType().getAsString(Policy);
582 : }
583 : }
584 :
585 : // Print the class definition
586 : // FIXME: Doesn't print access specifiers, e.g., "public:"
587 13: Out << " {\n";
13: branch 0 taken
0: branch 1 not taken
588 13: VisitDeclContext(D);
589 13: Indent() << "}";
590 : }
591 19: }
592 :
593 0: void DeclPrinter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
594 : const char *l;
0: branch 1 not taken
0: branch 2 not taken
595 0: if (D->getLanguage() == LinkageSpecDecl::lang_c)
596 0: l = "C";
597 : else {
598 : assert(D->getLanguage() == LinkageSpecDecl::lang_cxx &&
0: branch 1 not taken
0: branch 2 not taken
599 0: "unknown language in linkage specification");
600 0: l = "C++";
601 : }
602 :
603 0: Out << "extern \"" << l << "\" ";
0: branch 1 not taken
0: branch 2 not taken
604 0: if (D->hasBraces()) {
605 0: Out << "{\n";
0: branch 0 not taken
0: branch 1 not taken
606 0: VisitDeclContext(D);
607 0: Indent() << "}";
608 : } else
609 0: Visit(*D->decls_begin());
610 0: }
611 :
612 3: void DeclPrinter::VisitTemplateDecl(TemplateDecl *D) {
613 3: Out << "template <";
614 :
615 3: TemplateParameterList *Params = D->getTemplateParameters();
4: branch 1 taken
3: branch 2 taken
616 7: for (unsigned i = 0, e = Params->size(); i != e; ++i) {
1: branch 0 taken
3: branch 1 taken
617 4: if (i != 0)
618 1: Out << ", ";
619 :
620 4: const Decl *Param = Params->getParam(i);
3: branch 0 taken
1: branch 1 taken
621 4: if (const TemplateTypeParmDecl *TTP =
622 4: dyn_cast<TemplateTypeParmDecl>(Param)) {
623 :
624 : QualType ParamType =
625 3: Context.getTypeDeclType(const_cast<TemplateTypeParmDecl*>(TTP));
626 :
3: branch 1 taken
0: branch 2 not taken
627 3: if (TTP->wasDeclaredWithTypename())
628 3: Out << "typename ";
629 : else
630 0: Out << "class ";
631 :
0: branch 1 not taken
3: branch 2 taken
632 3: if (TTP->isParameterPack())
633 0: Out << "... ";
634 :
635 3: Out << ParamType.getAsString(Policy);
636 :
0: branch 1 not taken
3: branch 2 taken
637 3: if (TTP->hasDefaultArgument()) {
638 0: Out << " = ";
639 0: Out << TTP->getDefaultArgument().getAsString(Policy);
640 : };
1: branch 0 taken
0: branch 1 not taken
641 1: } else if (const NonTypeTemplateParmDecl *NTTP =
642 1: dyn_cast<NonTypeTemplateParmDecl>(Param)) {
643 1: Out << NTTP->getType().getAsString(Policy);
644 :
0: branch 1 not taken
1: branch 2 taken
645 1: if (IdentifierInfo *Name = NTTP->getIdentifier()) {
646 0: Out << ' ';
647 0: Out << Name->getName();
648 : }
649 :
0: branch 1 not taken
1: branch 2 taken
650 1: if (NTTP->hasDefaultArgument()) {
651 0: Out << " = ";
652 : NTTP->getDefaultArgument()->printPretty(Out, Context, 0, Policy,
653 0: Indentation);
654 : }
655 : }
656 : }
657 :
658 3: Out << "> ";
659 :
660 3: Visit(D->getTemplatedDecl());
661 3: }
662 :
663 : //----------------------------------------------------------------------------
664 : // Objective-C declarations
665 : //----------------------------------------------------------------------------
666 :
667 2: void DeclPrinter::VisitObjCClassDecl(ObjCClassDecl *D) {
668 2: Out << "@class ";
2: branch 2 taken
2: branch 3 taken
669 4: for (ObjCClassDecl::iterator I = D->begin(), E = D->end();
670 : I != E; ++I) {
0: branch 1 not taken
2: branch 2 taken
671 2: if (I != D->begin()) Out << ", ";
672 2: Out << I->getInterface()->getNameAsString();
673 : }
674 2: }
675 :
676 33: void DeclPrinter::VisitObjCMethodDecl(ObjCMethodDecl *OMD) {
31: branch 1 taken
2: branch 2 taken
677 33: if (OMD->isInstanceMethod())
678 31: Out << "- ";
679 : else
680 2: Out << "+ ";
33: branch 2 taken
0: branch 3 not taken
681 33: if (!OMD->getResultType().isNull())
682 33: Out << '(' << OMD->getResultType().getAsString(Policy) << ")";
683 :
684 33: std::string name = OMD->getSelector().getAsString();
685 33: std::string::size_type pos, lastPos = 0;
16: branch 1 taken
33: branch 2 taken
686 82: for (ObjCMethodDecl::param_iterator PI = OMD->param_begin(),
687 33: E = OMD->param_end(); PI != E; ++PI) {
688 : // FIXME: selector is missing here!
689 16: pos = name.find_first_of(":", lastPos);
690 16: Out << " " << name.substr(lastPos, pos - lastPos);
691 : Out << ":(" << (*PI)->getType().getAsString(Policy) << ")"
692 16: << (*PI)->getNameAsString();
693 16: lastPos = pos + 1;
694 : }
695 :
19: branch 2 taken
14: branch 3 taken
696 33: if (OMD->param_begin() == OMD->param_end())
697 19: Out << " " << name;
698 :
2: branch 1 taken
31: branch 2 taken
699 33: if (OMD->isVariadic())
700 2: Out << ", ...";
701 :
7: branch 1 taken
26: branch 2 taken
702 33: if (OMD->getBody()) {
703 7: Out << ' ';
704 7: OMD->getBody()->printPretty(Out, Context, 0, Policy);
705 7: Out << '\n';
706 33: }
707 33: }
708 :
709 5: void DeclPrinter::VisitObjCImplementationDecl(ObjCImplementationDecl *OID) {
710 5: std::string I = OID->getNameAsString();
711 5: ObjCInterfaceDecl *SID = OID->getSuperClass();
712 :
2: branch 0 taken
3: branch 1 taken
713 5: if (SID)
714 2: Out << "@implementation " << I << " : " << SID->getNameAsString();
715 : else
716 3: Out << "@implementation " << I;
717 5: Out << "\n";
5: branch 0 taken
0: branch 1 not taken
718 5: VisitDeclContext(OID, false);
719 5: Out << "@end";
720 5: }
721 :
722 13: void DeclPrinter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *OID) {
723 13: std::string I = OID->getNameAsString();
724 13: ObjCInterfaceDecl *SID = OID->getSuperClass();
725 :
4: branch 0 taken
9: branch 1 taken
726 13: if (SID)
727 4: Out << "@interface " << I << " : " << SID->getNameAsString();
728 : else
729 9: Out << "@interface " << I;
730 :
731 : // Protocols?
732 13: const ObjCList<ObjCProtocolDecl> &Protocols = OID->getReferencedProtocols();
2: branch 1 taken
11: branch 2 taken
733 13: if (!Protocols.empty()) {
2: branch 1 taken
2: branch 2 taken
734 6: for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
735 2: E = Protocols.end(); I != E; ++I)
2: branch 2 taken
0: branch 3 not taken
736 2: Out << (I == Protocols.begin() ? '<' : ',') << (*I)->getNameAsString();
737 : }
738 :
2: branch 1 taken
11: branch 2 taken
739 13: if (!Protocols.empty())
740 2: Out << "> ";
741 :
4: branch 1 taken
9: branch 2 taken
742 13: if (OID->ivar_size() > 0) {
743 4: Out << "{\n";
744 4: Indentation += Policy.Indentation;
12: branch 1 taken
4: branch 2 taken
745 20: for (ObjCInterfaceDecl::ivar_iterator I = OID->ivar_begin(),
746 4: E = OID->ivar_end(); I != E; ++I) {
747 : Indent() << (*I)->getType().getAsString(Policy)
748 12: << ' ' << (*I)->getNameAsString() << ";\n";
749 : }
750 4: Indentation -= Policy.Indentation;
751 4: Out << "}\n";
752 : }
753 :
13: branch 0 taken
0: branch 1 not taken
754 13: VisitDeclContext(OID, false);
755 13: Out << "@end";
756 : // FIXME: implement the rest...
757 13: }
758 :
759 2: void DeclPrinter::VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D) {
760 2: Out << "@protocol ";
2: branch 1 taken
2: branch 2 taken
761 6: for (ObjCForwardProtocolDecl::protocol_iterator I = D->protocol_begin(),
762 2: E = D->protocol_end();
763 : I != E; ++I) {
0: branch 1 not taken
2: branch 2 taken
764 2: if (I != D->protocol_begin()) Out << ", ";
765 2: Out << (*I)->getNameAsString();
766 : }
767 2: }
768 :
769 9: void DeclPrinter::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) {
770 9: Out << "@protocol " << PID->getNameAsString() << '\n';
9: branch 0 taken
0: branch 1 not taken
771 9: VisitDeclContext(PID, false);
772 9: Out << "@end";
773 9: }
774 :
775 2: void DeclPrinter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *PID) {
776 : Out << "@implementation "
777 : << PID->getClassInterface()->getNameAsString()
778 2: << '(' << PID->getNameAsString() << ")\n";
779 :
2: branch 0 taken
0: branch 1 not taken
780 2: VisitDeclContext(PID, false);
781 2: Out << "@end";
782 : // FIXME: implement the rest...
783 2: }
784 :
785 2: void DeclPrinter::VisitObjCCategoryDecl(ObjCCategoryDecl *PID) {
786 : Out << "@interface "
787 : << PID->getClassInterface()->getNameAsString()
788 2: << '(' << PID->getNameAsString() << ")\n";
2: branch 0 taken
0: branch 1 not taken
789 2: VisitDeclContext(PID, false);
790 2: Out << "@end";
791 :
792 : // FIXME: implement the rest...
793 2: }
794 :
795 1: void DeclPrinter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *AID) {
796 : Out << "@compatibility_alias " << AID->getNameAsString()
797 1: << ' ' << AID->getClassInterface()->getNameAsString() << ";\n";
798 1: }
799 :
800 : /// PrintObjCPropertyDecl - print a property declaration.
801 : ///
802 12: void DeclPrinter::VisitObjCPropertyDecl(ObjCPropertyDecl *PDecl) {
0: branch 1 not taken
12: branch 2 taken
803 12: if (PDecl->getPropertyImplementation() == ObjCPropertyDecl::Required)
804 0: Out << "@required\n";
0: branch 1 not taken
12: branch 2 taken
805 12: else if (PDecl->getPropertyImplementation() == ObjCPropertyDecl::Optional)
806 0: Out << "@optional\n";
807 :
808 12: Out << "@property";
12: branch 1 taken
0: branch 2 not taken
809 12: if (PDecl->getPropertyAttributes() != ObjCPropertyDecl::OBJC_PR_noattr) {
810 12: bool first = true;
811 12: Out << " (";
2: branch 1 taken
10: branch 2 taken
812 12: if (PDecl->getPropertyAttributes() &
813 : ObjCPropertyDecl::OBJC_PR_readonly) {
2: branch 0 taken
0: branch 1 not taken
814 2: Out << (first ? ' ' : ',') << "readonly";
815 2: first = false;
816 : }
817 :
2: branch 1 taken
10: branch 2 taken
818 12: if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) {
819 : Out << (first ? ' ' : ',') << "getter = "
2: branch 2 taken
0: branch 3 not taken
820 2: << PDecl->getGetterName().getAsString();
821 2: first = false;
822 : }
2: branch 1 taken
10: branch 2 taken
823 12: if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) {
824 : Out << (first ? ' ' : ',') << "setter = "
0: branch 2 not taken
2: branch 3 taken
825 2: << PDecl->getSetterName().getAsString();
826 2: first = false;
827 : }
828 :
6: branch 1 taken
6: branch 2 taken
829 12: if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_assign) {
4: branch 0 taken
2: branch 1 taken
830 6: Out << (first ? ' ' : ',') << "assign";
831 6: first = false;
832 : }
833 :
10: branch 1 taken
2: branch 2 taken
834 12: if (PDecl->getPropertyAttributes() &
835 : ObjCPropertyDecl::OBJC_PR_readwrite) {
4: branch 0 taken
6: branch 1 taken
836 10: Out << (first ? ' ' : ',') << "readwrite";
837 10: first = false;
838 : }
839 :
2: branch 1 taken
10: branch 2 taken
840 12: if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_retain) {
0: branch 0 not taken
2: branch 1 taken
841 2: Out << (first ? ' ' : ',') << "retain";
842 2: first = false;
843 : }
844 :
2: branch 1 taken
10: branch 2 taken
845 12: if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_copy) {
0: branch 0 not taken
2: branch 1 taken
846 2: Out << (first ? ' ' : ',') << "copy";
847 2: first = false;
848 : }
849 :
2: branch 1 taken
10: branch 2 taken
850 12: if (PDecl->getPropertyAttributes() &
851 : ObjCPropertyDecl::OBJC_PR_nonatomic) {
0: branch 0 not taken
2: branch 1 taken
852 2: Out << (first ? ' ' : ',') << "nonatomic";
853 2: first = false;
854 : }
855 12: Out << " )";
856 : }
857 : Out << ' ' << PDecl->getType().getAsString(Policy)
858 12: << ' ' << PDecl->getNameAsString();
859 12: }
860 :
861 6: void DeclPrinter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PID) {
4: branch 1 taken
2: branch 2 taken
862 6: if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
863 4: Out << "@synthesize ";
864 : else
865 2: Out << "@dynamic ";
866 6: Out << PID->getPropertyDecl()->getNameAsString();
4: branch 1 taken
2: branch 2 taken
867 6: if (PID->getPropertyIvarDecl())
868 4: Out << "=" << PID->getPropertyIvarDecl()->getNameAsString();
869 6: }
870 :
871 0: void DeclPrinter::VisitUsingDecl(UsingDecl *D) {
872 0: Out << "using ";
873 0: D->getTargetNestedNameDecl()->print(Out, Policy);
874 0: Out << D->getNameAsString();
875 0: }
876 :
877 : void
878 0: DeclPrinter::VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) {
879 0: Out << "using typename ";
880 0: D->getTargetNestedNameSpecifier()->print(Out, Policy);
881 0: Out << D->getDeclName().getAsString();
882 0: }
883 :
884 0: void DeclPrinter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
885 0: Out << "using ";
886 0: D->getTargetNestedNameSpecifier()->print(Out, Policy);
887 0: Out << D->getDeclName().getAsString();
888 0: }
889 :
890 0: void DeclPrinter::VisitUsingShadowDecl(UsingShadowDecl *D) {
891 : // ignore
892 0: }
Generated: 2010-02-10 01:31 by zcov