1 //===--- StmtIterator.h - Iterators for Statements --------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the StmtIterator and ConstStmtIterator classes.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CLANG_AST_STMTITERATOR_H
15 #define LLVM_CLANG_AST_STMTITERATOR_H
17 #include "llvm/Support/Compiler.h"
18 #include "llvm/Support/DataTypes.h"
28 class VariableArrayType;
30 class StmtIteratorBase {
32 enum { StmtMode = 0x0, SizeOfTypeVAMode = 0x1, DeclGroupMode = 0x2,
42 bool inDeclGroup() const {
43 return (RawVAPtr & Flags) == DeclGroupMode;
46 bool inSizeOfTypeVA() const {
47 return (RawVAPtr & Flags) == SizeOfTypeVAMode;
51 return (RawVAPtr & Flags) == StmtMode;
54 const VariableArrayType *getVAPtr() const {
55 return reinterpret_cast<const VariableArrayType*>(RawVAPtr & ~Flags);
58 void setVAPtr(const VariableArrayType *P) {
59 assert (inDeclGroup() || inSizeOfTypeVA());
60 RawVAPtr = reinterpret_cast<uintptr_t>(P) | (RawVAPtr & Flags);
63 void NextDecl(bool ImmediateAdvance = true);
64 bool HandleDecl(Decl* D);
67 Stmt*& GetDeclExpr() const;
69 StmtIteratorBase(Stmt **s) : stmt(s), RawVAPtr(0) {}
70 StmtIteratorBase(const VariableArrayType *t);
71 StmtIteratorBase(Decl **dgi, Decl **dge);
72 StmtIteratorBase() : stmt(nullptr), RawVAPtr(0) {}
76 template <typename DERIVED, typename REFERENCE>
77 class StmtIteratorImpl : public StmtIteratorBase,
78 public std::iterator<std::forward_iterator_tag,
80 REFERENCE, REFERENCE> {
82 StmtIteratorImpl(const StmtIteratorBase& RHS) : StmtIteratorBase(RHS) {}
85 StmtIteratorImpl(Stmt **s) : StmtIteratorBase(s) {}
86 StmtIteratorImpl(Decl **dgi, Decl **dge) : StmtIteratorBase(dgi, dge) {}
87 StmtIteratorImpl(const VariableArrayType *t) : StmtIteratorBase(t) {}
89 DERIVED& operator++() {
97 return static_cast<DERIVED&>(*this);
100 DERIVED operator++(int) {
101 DERIVED tmp = static_cast<DERIVED&>(*this);
106 bool operator==(const DERIVED& RHS) const {
107 return stmt == RHS.stmt && DGI == RHS.DGI && RawVAPtr == RHS.RawVAPtr;
110 bool operator!=(const DERIVED& RHS) const {
111 return stmt != RHS.stmt || DGI != RHS.DGI || RawVAPtr != RHS.RawVAPtr;
114 REFERENCE operator*() const {
115 return inStmt() ? *stmt : GetDeclExpr();
118 REFERENCE operator->() const { return operator*(); }
121 struct ConstStmtIterator;
123 struct StmtIterator : public StmtIteratorImpl<StmtIterator,Stmt*&> {
124 explicit StmtIterator() : StmtIteratorImpl<StmtIterator,Stmt*&>() {}
126 StmtIterator(Stmt** S) : StmtIteratorImpl<StmtIterator,Stmt*&>(S) {}
128 StmtIterator(Decl** dgi, Decl** dge)
129 : StmtIteratorImpl<StmtIterator,Stmt*&>(dgi, dge) {}
131 StmtIterator(const VariableArrayType *t)
132 : StmtIteratorImpl<StmtIterator,Stmt*&>(t) {}
135 StmtIterator(const StmtIteratorBase &RHS)
136 : StmtIteratorImpl<StmtIterator, Stmt *&>(RHS) {}
138 inline friend StmtIterator
139 cast_away_const(const ConstStmtIterator &RHS);
142 struct ConstStmtIterator : public StmtIteratorImpl<ConstStmtIterator,
144 explicit ConstStmtIterator() :
145 StmtIteratorImpl<ConstStmtIterator,const Stmt*>() {}
147 ConstStmtIterator(const StmtIterator& RHS) :
148 StmtIteratorImpl<ConstStmtIterator,const Stmt*>(RHS) {}
150 ConstStmtIterator(Stmt * const *S)
151 : StmtIteratorImpl<ConstStmtIterator, const Stmt *>(
152 const_cast<Stmt **>(S)) {}
155 inline StmtIterator cast_away_const(const ConstStmtIterator &RHS) {
158 } // end namespace clang