contrib/llvm/tools/clang/include/clang/AST/StmtIterator.h

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