1 //===--- StmtIterator.h - Iterators for Statements --------------*- C++ -*-===// 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/Support/DataTypes.h" 18 #include <cassert> 19 #include <cstddef> 20 #include <iterator> 21 #include <utility> 22 23 namespace clang { 24 25 class Stmt; 26 class Decl; 27 class VariableArrayType; 28 29 class StmtIteratorBase { 30 protected: 31 enum { DeclMode = 0x1, SizeOfTypeVAMode = 0x2, DeclGroupMode = 0x3, 32 Flags = 0x3 }; 33 34 Stmt **stmt; 35 union { Decl *decl; Decl **DGI; }; 36 uintptr_t RawVAPtr; 37 Decl **DGE; 38 39 bool inDecl() const { 40 return (RawVAPtr & Flags) == DeclMode; 41 } 42 43 bool inDeclGroup() const { 44 return (RawVAPtr & Flags) == DeclGroupMode; 45 } 46 47 bool inSizeOfTypeVA() const { 48 return (RawVAPtr & Flags) == SizeOfTypeVAMode; 49 } 50 51 bool inStmt() const { 52 return (RawVAPtr & Flags) == 0; 53 } 54 55 const VariableArrayType *getVAPtr() const { 56 return reinterpret_cast<const VariableArrayType*>(RawVAPtr & ~Flags); 57 } 58 59 void setVAPtr(const VariableArrayType *P) { 60 assert (inDecl() || inDeclGroup() || inSizeOfTypeVA()); 61 RawVAPtr = reinterpret_cast<uintptr_t>(P) | (RawVAPtr & Flags); 62 } 63 64 void NextDecl(bool ImmediateAdvance = true); 65 bool HandleDecl(Decl* D); 66 void NextVA(); 67 68 Stmt*& GetDeclExpr() const; 69 70 StmtIteratorBase(Stmt **s) : stmt(s), decl(0), RawVAPtr(0) {} 71 StmtIteratorBase(Decl *d, Stmt **s); 72 StmtIteratorBase(const VariableArrayType *t); 73 StmtIteratorBase(Decl **dgi, Decl **dge); 74 StmtIteratorBase() : stmt(0), decl(0), RawVAPtr(0) {} 75 }; 76 77 78 template <typename DERIVED, typename REFERENCE> 79 class StmtIteratorImpl : public StmtIteratorBase, 80 public std::iterator<std::forward_iterator_tag, 81 REFERENCE, ptrdiff_t, 82 REFERENCE, REFERENCE> { 83 protected: 84 StmtIteratorImpl(const StmtIteratorBase& RHS) : StmtIteratorBase(RHS) {} 85 public: 86 StmtIteratorImpl() {} 87 StmtIteratorImpl(Stmt **s) : StmtIteratorBase(s) {} 88 StmtIteratorImpl(Decl **dgi, Decl **dge) : StmtIteratorBase(dgi, dge) {} 89 StmtIteratorImpl(Decl *d, Stmt **s) : StmtIteratorBase(d, s) {} 90 StmtIteratorImpl(const VariableArrayType *t) : StmtIteratorBase(t) {} 91 92 DERIVED& operator++() { 93 if (inDecl() || inDeclGroup()) { 94 if (getVAPtr()) NextVA(); 95 else NextDecl(); 96 } 97 else if (inSizeOfTypeVA()) 98 NextVA(); 99 else 100 ++stmt; 101 102 return static_cast<DERIVED&>(*this); 103 } 104 105 DERIVED operator++(int) { 106 DERIVED tmp = static_cast<DERIVED&>(*this); 107 operator++(); 108 return tmp; 109 } 110 111 bool operator==(const DERIVED& RHS) const { 112 return stmt == RHS.stmt && decl == RHS.decl && RawVAPtr == RHS.RawVAPtr; 113 } 114 115 bool operator!=(const DERIVED& RHS) const { 116 return stmt != RHS.stmt || decl != RHS.decl || RawVAPtr != RHS.RawVAPtr; 117 } 118 119 REFERENCE operator*() const { 120 return (REFERENCE) (inStmt() ? *stmt : GetDeclExpr()); 121 } 122 123 REFERENCE operator->() const { return operator*(); } 124 }; 125 126 struct StmtIterator : public StmtIteratorImpl<StmtIterator,Stmt*&> { 127 explicit StmtIterator() : StmtIteratorImpl<StmtIterator,Stmt*&>() {} 128 129 StmtIterator(Stmt** S) : StmtIteratorImpl<StmtIterator,Stmt*&>(S) {} 130 131 StmtIterator(Decl** dgi, Decl** dge) 132 : StmtIteratorImpl<StmtIterator,Stmt*&>(dgi, dge) {} 133 134 StmtIterator(const VariableArrayType *t) 135 : StmtIteratorImpl<StmtIterator,Stmt*&>(t) {} 136 137 StmtIterator(Decl* D, Stmt **s = 0) 138 : StmtIteratorImpl<StmtIterator,Stmt*&>(D, s) {} 139 }; 140 141 struct ConstStmtIterator : public StmtIteratorImpl<ConstStmtIterator, 142 const Stmt*> { 143 explicit ConstStmtIterator() : 144 StmtIteratorImpl<ConstStmtIterator,const Stmt*>() {} 145 146 ConstStmtIterator(const StmtIterator& RHS) : 147 StmtIteratorImpl<ConstStmtIterator,const Stmt*>(RHS) {} 148 }; 149 150 /// A range of statement iterators. 151 /// 152 /// This class provides some extra functionality beyond std::pair 153 /// in order to allow the following idiom: 154 /// for (StmtRange range = stmt->children(); range; ++range) 155 struct StmtRange : std::pair<StmtIterator,StmtIterator> { 156 StmtRange() {} 157 StmtRange(const StmtIterator &begin, const StmtIterator &end) 158 : std::pair<StmtIterator,StmtIterator>(begin, end) {} 159 160 bool empty() const { return first == second; } 161 operator bool() const { return !empty(); } 162 163 Stmt *operator->() const { return first.operator->(); } 164 Stmt *&operator*() const { return first.operator*(); } 165 166 StmtRange &operator++() { 167 assert(!empty() && "incrementing on empty range"); 168 ++first; 169 return *this; 170 } 171 172 StmtRange operator++(int) { 173 assert(!empty() && "incrementing on empty range"); 174 StmtRange copy = *this; 175 ++first; 176 return copy; 177 } 178 179 friend const StmtIterator &begin(const StmtRange &range) { 180 return range.first; 181 } 182 friend const StmtIterator &end(const StmtRange &range) { 183 return range.second; 184 } 185 }; 186 187 /// A range of const statement iterators. 188 /// 189 /// This class provides some extra functionality beyond std::pair 190 /// in order to allow the following idiom: 191 /// for (ConstStmtRange range = stmt->children(); range; ++range) 192 struct ConstStmtRange : std::pair<ConstStmtIterator,ConstStmtIterator> { 193 ConstStmtRange() {} 194 ConstStmtRange(const ConstStmtIterator &begin, 195 const ConstStmtIterator &end) 196 : std::pair<ConstStmtIterator,ConstStmtIterator>(begin, end) {} 197 ConstStmtRange(const StmtRange &range) 198 : std::pair<ConstStmtIterator,ConstStmtIterator>(range.first, range.second) 199 {} 200 ConstStmtRange(const StmtIterator &begin, const StmtIterator &end) 201 : std::pair<ConstStmtIterator,ConstStmtIterator>(begin, end) {} 202 203 bool empty() const { return first == second; } 204 operator bool() const { return !empty(); } 205 206 const Stmt *operator->() const { return first.operator->(); } 207 const Stmt *operator*() const { return first.operator*(); } 208 209 ConstStmtRange &operator++() { 210 assert(!empty() && "incrementing on empty range"); 211 ++first; 212 return *this; 213 } 214 215 ConstStmtRange operator++(int) { 216 assert(!empty() && "incrementing on empty range"); 217 ConstStmtRange copy = *this; 218 ++first; 219 return copy; 220 } 221 222 friend const ConstStmtIterator &begin(const ConstStmtRange &range) { 223 return range.first; 224 } 225 friend const ConstStmtIterator &end(const ConstStmtRange &range) { 226 return range.second; 227 } 228 }; 229 230 } // end namespace clang 231 232 #endif 233
