Home | History | Annotate | Download | only in AST
      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
    223