 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
73.2% |
60 / 82 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
87.8% |
72 / 82 |
| |
|
Line Coverage: |
89.4% |
76 / 85 |
| |
 |
|
 |
1 : //===--- StmtIterator.cpp - Iterators for Statements ------------------------===//
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 defines internal methods for StmtIterator.
11 : //
12 : //===----------------------------------------------------------------------===//
13 :
14 : #include "clang/AST/StmtIterator.h"
15 : #include "clang/AST/Decl.h"
16 :
17 : using namespace clang;
18 :
19 : // FIXME: Add support for dependent-sized array types in C++?
20 : // Does it even make sense to build a CFG for an uninstantiated template?
21 4031: static inline VariableArrayType* FindVA(Type* t) {
242: branch 1 taken
3789: branch 2 taken
22 4205: while (ArrayType* vt = dyn_cast<ArrayType>(t)) {
68: branch 1 taken
174: branch 2 taken
23 242: if (VariableArrayType* vat = dyn_cast<VariableArrayType>(vt))
68: branch 1 taken
0: branch 2 not taken
24 68: if (vat->getSizeExpr())
25 68: return vat;
26 :
27 174: t = vt->getElementType().getTypePtr();
28 : }
29 :
30 3789: return NULL;
31 : }
32 :
33 190: void StmtIteratorBase::NextVA() {
0: branch 1 not taken
190: branch 2 taken
34 190: assert (getVAPtr());
35 :
36 190: VariableArrayType* p = getVAPtr();
37 190: p = FindVA(p->getElementType().getTypePtr());
38 190: setVAPtr(p);
39 :
8: branch 0 taken
182: branch 1 taken
40 190: if (p)
41 8: return;
42 :
0: branch 1 not taken
182: branch 2 taken
43 182: if (inDecl()) {
0: branch 1 not taken
0: branch 2 not taken
44 0: if (VarDecl* VD = dyn_cast<VarDecl>(decl))
0: branch 1 not taken
0: branch 2 not taken
45 0: if (VD->Init)
46 0: return;
47 :
48 0: NextDecl();
49 : }
60: branch 1 taken
122: branch 2 taken
50 182: else if (inDeclGroup()) {
52: branch 1 taken
8: branch 2 taken
51 60: if (VarDecl* VD = dyn_cast<VarDecl>(*DGI))
0: branch 1 not taken
52: branch 2 taken
52 52: if (VD->Init)
53 0: return;
54 :
55 60: NextDecl();
56 : }
57 : else {
0: branch 1 not taken
122: branch 2 taken
58 122: assert (inSizeOfTypeVA());
0: branch 0 not taken
122: branch 1 taken
59 122: assert(!decl);
60 122: RawVAPtr = 0;
61 : }
62 : }
63 :
64 10221: void StmtIteratorBase::NextDecl(bool ImmediateAdvance) {
0: branch 1 not taken
10221: branch 2 taken
65 10221: assert (getVAPtr() == NULL);
66 :
16: branch 1 taken
10205: branch 2 taken
67 10221: if (inDecl()) {
0: branch 0 not taken
16: branch 1 taken
68 16: assert(decl);
69 :
70 : // FIXME: SIMPLIFY AWAY.
8: branch 0 taken
8: branch 1 taken
71 16: if (ImmediateAdvance)
72 8: decl = 0;
8: branch 1 taken
0: branch 2 not taken
73 8: else if (HandleDecl(decl))
74 8: return;
75 : }
76 : else {
0: branch 1 not taken
10205: branch 2 taken
77 10205: assert(inDeclGroup());
78 :
2747: branch 0 taken
7458: branch 1 taken
79 10205: if (ImmediateAdvance)
80 2747: ++DGI;
81 :
3764: branch 0 taken
7458: branch 1 taken
82 11222: for ( ; DGI != DGE; ++DGI)
2747: branch 1 taken
1017: branch 2 taken
83 3764: if (HandleDecl(*DGI))
84 2747: return;
85 : }
86 :
87 7466: RawVAPtr = 0;
88 : }
89 :
90 3772: bool StmtIteratorBase::HandleDecl(Decl* D) {
91 :
3618: branch 1 taken
154: branch 2 taken
92 3772: if (VarDecl* VD = dyn_cast<VarDecl>(D)) {
52: branch 3 taken
3566: branch 4 taken
93 3618: if (VariableArrayType* VAPtr = FindVA(VD->getType().getTypePtr())) {
94 52: setVAPtr(VAPtr);
95 52: return true;
96 : }
97 :
2695: branch 1 taken
871: branch 2 taken
98 3566: if (VD->getInit())
99 2695: return true;
100 : }
49: branch 1 taken
105: branch 2 taken
101 154: else if (TypedefDecl* TD = dyn_cast<TypedefDecl>(D)) {
8: branch 0 taken
41: branch 1 taken
102 49: if (VariableArrayType* VAPtr =
103 49: FindVA(TD->getUnderlyingType().getTypePtr())) {
104 8: setVAPtr(VAPtr);
105 8: return true;
106 : }
107 : }
0: branch 1 not taken
105: branch 2 taken
108 105: else if (EnumConstantDecl* ECD = dyn_cast<EnumConstantDecl>(D)) {
0: branch 1 not taken
0: branch 2 not taken
109 0: if (ECD->getInitExpr())
110 0: return true;
111 : }
112 :
113 1017: return false;
114 : }
115 :
116 972: StmtIteratorBase::StmtIteratorBase(Decl *d, Stmt **s)
972: branch 0 taken
972: branch 1 taken
8: branch 2 taken
964: branch 3 taken
117 972: : stmt(s), decl(d), RawVAPtr(d ? DeclMode : 0) {
972: branch 0 taken
972: branch 1 taken
8: branch 2 taken
964: branch 3 taken
118 972: if (decl)
119 8: NextDecl(false);
120 972: }
121 :
122 7458: StmtIteratorBase::StmtIteratorBase(Decl** dgi, Decl** dge)
123 7458: : stmt(0), DGI(dgi), RawVAPtr(DeclGroupMode), DGE(dge) {
124 7458: NextDecl(false);
125 7458: }
126 :
127 122: StmtIteratorBase::StmtIteratorBase(VariableArrayType* t)
128 122: : stmt(0), decl(0), RawVAPtr(SizeOfTypeVAMode) {
129 122: RawVAPtr |= reinterpret_cast<uintptr_t>(t);
130 122: }
131 :
132 4751: Stmt*& StmtIteratorBase::GetDeclExpr() const {
133 :
277: branch 1 taken
4474: branch 2 taken
134 4751: if (VariableArrayType* VAPtr = getVAPtr()) {
0: branch 0 not taken
277: branch 1 taken
135 277: assert (VAPtr->SizeExpr);
136 277: return VAPtr->SizeExpr;
137 : }
138 :
4466: branch 1 taken
8: branch 2 taken
0: branch 4 not taken
4466: branch 5 taken
139 4474: assert (inDecl() || inDeclGroup());
140 :
4466: branch 1 taken
8: branch 2 taken
141 4474: if (inDeclGroup()) {
142 4466: VarDecl* VD = cast<VarDecl>(*DGI);
143 4466: return *VD->getInitAddress();
144 : }
145 :
0: branch 1 not taken
8: branch 2 taken
146 8: assert (inDecl());
147 :
8: branch 1 taken
0: branch 2 not taken
148 8: if (VarDecl* VD = dyn_cast<VarDecl>(decl)) {
0: branch 1 not taken
8: branch 2 taken
149 8: assert (VD->Init);
150 8: return *VD->getInitAddress();
151 : }
152 :
153 0: EnumConstantDecl* ECD = cast<EnumConstantDecl>(decl);
154 0: return ECD->Init;
155 : }
Generated: 2010-02-10 01:31 by zcov