1 files changed, 145 insertions, 0 deletions
diff --git a/include/clang/AST/StmtIterator.h b/include/clang/AST/StmtIterator.h
new file mode 100644
index 0000000..35bd5ad
--- /dev/null
+++ b/include/clang/AST/StmtIterator.h
@@ -0,0 +1,145 @@
+//===--- StmtIterator.h - Iterators for Statements ------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the StmtIterator and ConstStmtIterator classes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_STMT_ITR_H
+#define LLVM_CLANG_AST_STMT_ITR_H
+
+#include "llvm/ADT/iterator.h"
+#include "llvm/Support/DataTypes.h"
+#include <cassert>
+
+namespace clang {
+
+class Stmt;
+class Decl;
+class VariableArrayType;
+  
+class StmtIteratorBase {
+protected:
+  enum { DeclMode = 0x1, SizeOfTypeVAMode = 0x2, DeclGroupMode = 0x3,
+         Flags = 0x3 };
+  
+  union { Stmt** stmt; Decl* decl; Decl** DGI; };
+  uintptr_t RawVAPtr;  
+  Decl** DGE;
+
+  bool inDecl() const {
+    return (RawVAPtr & Flags) == DeclMode;
+  }
+  
+  bool inDeclGroup() const {
+    return (RawVAPtr & Flags) == DeclGroupMode;
+  }
+  
+  bool inSizeOfTypeVA() const { 
+    return (RawVAPtr & Flags) == SizeOfTypeVAMode;
+  }
+  
+  bool inStmt() const {
+    return (RawVAPtr & Flags) == 0;
+  }
+    
+  VariableArrayType* getVAPtr() const {
+    return reinterpret_cast<VariableArrayType*>(RawVAPtr & ~Flags);
+  }
+  
+  void setVAPtr(VariableArrayType* P) {
+    assert (inDecl() || inDeclGroup() || inSizeOfTypeVA());    
+    RawVAPtr = reinterpret_cast<uintptr_t>(P) | (RawVAPtr & Flags);
+  }
+  
+  void NextDecl(bool ImmediateAdvance = true);
+  bool HandleDecl(Decl* D);
+  void NextVA();
+  
+  Stmt*& GetDeclExpr() const;
+
+  StmtIteratorBase(Stmt** s) : stmt(s), RawVAPtr(0) {}
+  StmtIteratorBase(Decl* d);
+  StmtIteratorBase(VariableArrayType* t);
+  StmtIteratorBase(Decl** dgi, Decl** dge);
+  StmtIteratorBase() : stmt(NULL), RawVAPtr(0) {}
+};
+  
+  
+template <typename DERIVED, typename REFERENCE>
+class StmtIteratorImpl : public StmtIteratorBase, 
+                         public std::iterator<std::forward_iterator_tag,
+                                              REFERENCE, ptrdiff_t, 
+                                              REFERENCE, REFERENCE> {  
+protected:
+  StmtIteratorImpl(const StmtIteratorBase& RHS) : StmtIteratorBase(RHS) {}
+public:
+  StmtIteratorImpl() {}                                                
+  StmtIteratorImpl(Stmt** s) : StmtIteratorBase(s) {}
+  StmtIteratorImpl(Decl** dgi, Decl** dge) : StmtIteratorBase(dgi, dge) {}
+  StmtIteratorImpl(Decl* d) : StmtIteratorBase(d) {}
+  StmtIteratorImpl(VariableArrayType* t) : StmtIteratorBase(t) {}
+  
+  DERIVED& operator++() {
+    if (inDecl() || inDeclGroup()) {
+      if (getVAPtr()) NextVA();
+      else NextDecl();
+    }
+    else if (inSizeOfTypeVA())
+      NextVA();
+    else
+      ++stmt;
+      
+    return static_cast<DERIVED&>(*this);
+  }
+    
+  DERIVED operator++(int) {
+    DERIVED tmp = static_cast<DERIVED&>(*this);
+    operator++();
+    return tmp;
+  }
+  
+  bool operator==(const DERIVED& RHS) const {
+    return stmt == RHS.stmt && RawVAPtr == RHS.RawVAPtr;
+  }
+  
+  bool operator!=(const DERIVED& RHS) const {
+    return stmt != RHS.stmt || RawVAPtr != RHS.RawVAPtr;
+  }
+  
+  REFERENCE operator*() const { 
+    return (REFERENCE) (inStmt() ? *stmt : GetDeclExpr());
+  }
+  
+  REFERENCE operator->() const { return operator*(); }   
+};
+
+struct StmtIterator : public StmtIteratorImpl<StmtIterator,Stmt*&> {
+  explicit StmtIterator() : StmtIteratorImpl<StmtIterator,Stmt*&>() {}
+
+  StmtIterator(Stmt** S) : StmtIteratorImpl<StmtIterator,Stmt*&>(S) {}
+  StmtIterator(Decl** dgi, Decl** dge) 
+   : StmtIteratorImpl<StmtIterator,Stmt*&>(dgi, dge) {}
+
+  StmtIterator(VariableArrayType* t):StmtIteratorImpl<StmtIterator,Stmt*&>(t) {}
+  StmtIterator(Decl* D) : StmtIteratorImpl<StmtIterator,Stmt*&>(D) {}
+};
+
+struct ConstStmtIterator : public StmtIteratorImpl<ConstStmtIterator,
+                                                   const Stmt*> {
+  explicit ConstStmtIterator() : 
+    StmtIteratorImpl<ConstStmtIterator,const Stmt*>() {}
+                                                     
+  ConstStmtIterator(const StmtIterator& RHS) : 
+    StmtIteratorImpl<ConstStmtIterator,const Stmt*>(RHS) {}
+};
+
+} // end namespace clang
+
+#endif