 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
54.2% |
13 / 24 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
91.7% |
22 / 24 |
| |
|
Line Coverage: |
92.2% |
47 / 51 |
| |
 |
|
 |
1 : //===--- StmtIterator.h - 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 the StmtIterator and ConstStmtIterator classes.
11 : //
12 : //===----------------------------------------------------------------------===//
13 :
14 : #ifndef LLVM_CLANG_AST_STMT_ITR_H
15 : #define LLVM_CLANG_AST_STMT_ITR_H
16 :
17 : #include "llvm/System/DataTypes.h"
18 : #include <cassert>
19 : #include <iterator>
20 :
21 : namespace clang {
22 :
23 : class Stmt;
24 : class Decl;
25 : class VariableArrayType;
26 :
27 : class StmtIteratorBase {
28 : protected:
29 : enum { DeclMode = 0x1, SizeOfTypeVAMode = 0x2, DeclGroupMode = 0x3,
30 : Flags = 0x3 };
31 :
32 : Stmt **stmt;
33 : union { Decl *decl; Decl **DGI; };
34 : uintptr_t RawVAPtr;
35 : Decl **DGE;
36 :
37 185854: bool inDecl() const {
38 185854: return (RawVAPtr & Flags) == DeclMode;
39 : }
40 :
41 190288: bool inDeclGroup() const {
42 190288: return (RawVAPtr & Flags) == DeclGroupMode;
43 : }
44 :
45 168200: bool inSizeOfTypeVA() const {
46 168200: return (RawVAPtr & Flags) == SizeOfTypeVAMode;
47 : }
48 :
49 318605: bool inStmt() const {
50 318605: return (RawVAPtr & Flags) == 0;
51 : }
52 :
53 18115: VariableArrayType* getVAPtr() const {
54 18115: return reinterpret_cast<VariableArrayType*>(RawVAPtr & ~Flags);
55 : }
56 :
57 250: void setVAPtr(VariableArrayType* P) {
250: branch 1 taken
0: branch 2 not taken
122: branch 4 taken
128: branch 5 taken
0: branch 7 not taken
122: branch 8 taken
58 250: assert (inDecl() || inDeclGroup() || inSizeOfTypeVA());
59 250: RawVAPtr = reinterpret_cast<uintptr_t>(P) | (RawVAPtr & Flags);
60 250: }
61 :
62 : void NextDecl(bool ImmediateAdvance = true);
63 : bool HandleDecl(Decl* D);
64 : void NextVA();
65 :
66 : Stmt*& GetDeclExpr() const;
67 :
68 247204: StmtIteratorBase(Stmt **s) : stmt(s), decl(0), RawVAPtr(0) {}
69 : StmtIteratorBase(Decl *d, Stmt **s);
70 : StmtIteratorBase(VariableArrayType *t);
71 : StmtIteratorBase(Decl **dgi, Decl **dge);
72 140632: StmtIteratorBase() : stmt(0), decl(0), RawVAPtr(0) {}
73 : };
74 :
75 :
76 : template <typename DERIVED, typename REFERENCE>
77 : class StmtIteratorImpl : public StmtIteratorBase,
78 : public std::iterator<std::forward_iterator_tag,
79 : REFERENCE, ptrdiff_t,
80 : REFERENCE, REFERENCE> {
81 : protected:
82 2570: StmtIteratorImpl(const StmtIteratorBase& RHS) : StmtIteratorBase(RHS) {}
83 : public:
84 140632: StmtIteratorImpl() {}
85 247204: StmtIteratorImpl(Stmt **s) : StmtIteratorBase(s) {}
86 7458: StmtIteratorImpl(Decl **dgi, Decl **dge) : StmtIteratorBase(dgi, dge) {}
87 972: StmtIteratorImpl(Decl *d, Stmt **s) : StmtIteratorBase(d, s) {}
88 122: StmtIteratorImpl(VariableArrayType* t) : StmtIteratorBase(t) {}
89 :
90 170719: DERIVED& operator++() {
170711: branch 1 taken
0: branch 2 not taken
0: branch 4 not taken
1818: branch 5 taken
0: branch 6 not taken
1818: branch 7 taken
91 170719: if (inDecl() || inDeclGroup()) {
0: branch 1 not taken
0: branch 2 not taken
92 2763: if (getVAPtr()) NextVA();
93 2695: else NextDecl();
94 : }
0: branch 1 not taken
1818: branch 2 taken
95 167956: else if (inSizeOfTypeVA())
96 122: NextVA();
97 : else
98 167834: ++stmt;
99 :
100 170719: return static_cast<DERIVED&>(*this);
101 : }
102 :
103 2706: DERIVED operator++(int) {
104 2706: DERIVED tmp = static_cast<DERIVED&>(*this);
105 2706: operator++();
106 : return tmp;
107 : }
108 :
109 0: bool operator==(const DERIVED& RHS) const {
110 0: return stmt == RHS.stmt && decl == RHS.decl && RawVAPtr == RHS.RawVAPtr;
111 : }
112 :
113 368483: bool operator!=(const DERIVED& RHS) const {
538: branch 0 taken
1818: branch 1 taken
538: branch 2 taken
0: branch 3 not taken
0: branch 4 not taken
538: branch 5 taken
114 368483: return stmt != RHS.stmt || decl != RHS.decl || RawVAPtr != RHS.RawVAPtr;
115 : }
116 :
117 318605: REFERENCE operator*() const {
3633: branch 1 taken
0: branch 2 not taken
118 318605: return (REFERENCE) (inStmt() ? *stmt : GetDeclExpr());
119 : }
120 :
121 : REFERENCE operator->() const { return operator*(); }
122 : };
123 :
124 : struct StmtIterator : public StmtIteratorImpl<StmtIterator,Stmt*&> {
125 140632: explicit StmtIterator() : StmtIteratorImpl<StmtIterator,Stmt*&>() {}
126 :
127 247204: StmtIterator(Stmt** S) : StmtIteratorImpl<StmtIterator,Stmt*&>(S) {}
128 :
129 7458: StmtIterator(Decl** dgi, Decl** dge)
130 7458: : StmtIteratorImpl<StmtIterator,Stmt*&>(dgi, dge) {}
131 :
132 122: StmtIterator(VariableArrayType* t)
133 122: : StmtIteratorImpl<StmtIterator,Stmt*&>(t) {}
134 :
135 972: StmtIterator(Decl* D, Stmt **s = 0)
136 972: : StmtIteratorImpl<StmtIterator,Stmt*&>(D, s) {}
137 : };
138 :
139 : struct ConstStmtIterator : public StmtIteratorImpl<ConstStmtIterator,
140 : const Stmt*> {
141 0: explicit ConstStmtIterator() :
142 0: StmtIteratorImpl<ConstStmtIterator,const Stmt*>() {}
143 :
144 2570: ConstStmtIterator(const StmtIterator& RHS) :
145 2570: StmtIteratorImpl<ConstStmtIterator,const Stmt*>(RHS) {}
146 : };
147 :
148 : } // end namespace clang
149 :
150 : #endif
Generated: 2010-02-10 01:31 by zcov