1 //===-- Redeclarable.h - Base for Decls that can be redeclared -*- 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 Redeclarable interface. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CLANG_AST_REDECLARABLE_H 15 #define LLVM_CLANG_AST_REDECLARABLE_H 16 17 #include "llvm/ADT/PointerIntPair.h" 18 #include "llvm/Support/Casting.h" 19 #include <iterator> 20 21 namespace clang { 22 23 /// \brief Provides common interface for the Decls that can be redeclared. 24 template<typename decl_type> 25 class Redeclarable { 26 27 protected: 28 // FIXME: PointerIntPair is a value class that should not be inherited from. 29 // This should change to using containment. 30 struct DeclLink : public llvm::PointerIntPair<decl_type *, 1, bool> { 31 DeclLink(decl_type *D, bool isLatest) 32 : llvm::PointerIntPair<decl_type *, 1, bool>(D, isLatest) { } 33 34 typedef llvm::PointerIntPair<decl_type *, 1, bool> base_type; 35 36 bool NextIsPrevious() const { return base_type::getInt() == false; } 37 bool NextIsLatest() const { return base_type::getInt() == true; } 38 decl_type *getNext() const { return base_type::getPointer(); } 39 }; 40 41 struct PreviousDeclLink : public DeclLink { 42 PreviousDeclLink(decl_type *D) : DeclLink(D, false) { } 43 }; 44 45 struct LatestDeclLink : public DeclLink { 46 LatestDeclLink(decl_type *D) : DeclLink(D, true) { } 47 }; 48 49 /// \brief Points to the next redeclaration in the chain. 50 /// 51 /// If NextIsPrevious() is true, this is a link to the previous declaration 52 /// of this same Decl. If NextIsLatest() is true, this is the first 53 /// declaration and Link points to the latest declaration. For example: 54 /// 55 /// #1 int f(int x, int y = 1); // <pointer to #3, true> 56 /// #2 int f(int x = 0, int y); // <pointer to #1, false> 57 /// #3 int f(int x, int y) { return x + y; } // <pointer to #2, false> 58 /// 59 /// If there is only one declaration, it is <pointer to self, true> 60 DeclLink RedeclLink; 61 62 public: 63 Redeclarable() : RedeclLink(LatestDeclLink(static_cast<decl_type*>(this))) { } 64 65 /// \brief Return the previous declaration of this declaration or NULL if this 66 /// is the first declaration. 67 decl_type *getPreviousDecl() { 68 if (RedeclLink.NextIsPrevious()) 69 return RedeclLink.getNext(); 70 return 0; 71 } 72 const decl_type *getPreviousDecl() const { 73 return const_cast<decl_type *>( 74 static_cast<const decl_type*>(this))->getPreviousDecl(); 75 } 76 77 /// \brief Return the first declaration of this declaration or itself if this 78 /// is the only declaration. 79 decl_type *getFirstDeclaration() { 80 decl_type *D = static_cast<decl_type*>(this); 81 while (D->getPreviousDecl()) 82 D = D->getPreviousDecl(); 83 return D; 84 } 85 86 /// \brief Return the first declaration of this declaration or itself if this 87 /// is the only declaration. 88 const decl_type *getFirstDeclaration() const { 89 const decl_type *D = static_cast<const decl_type*>(this); 90 while (D->getPreviousDecl()) 91 D = D->getPreviousDecl(); 92 return D; 93 } 94 95 /// \brief Returns true if this is the first declaration. 96 bool isFirstDeclaration() const { 97 return RedeclLink.NextIsLatest(); 98 } 99 100 /// \brief Returns the most recent (re)declaration of this declaration. 101 decl_type *getMostRecentDecl() { 102 return getFirstDeclaration()->RedeclLink.getNext(); 103 } 104 105 /// \brief Returns the most recent (re)declaration of this declaration. 106 const decl_type *getMostRecentDecl() const { 107 return getFirstDeclaration()->RedeclLink.getNext(); 108 } 109 110 /// \brief Set the previous declaration. If PrevDecl is NULL, set this as the 111 /// first and only declaration. 112 void setPreviousDeclaration(decl_type *PrevDecl); 113 114 /// \brief Iterates through all the redeclarations of the same decl. 115 class redecl_iterator { 116 /// Current - The current declaration. 117 decl_type *Current; 118 decl_type *Starter; 119 bool PassedFirst; 120 121 public: 122 typedef decl_type* value_type; 123 typedef decl_type* reference; 124 typedef decl_type* pointer; 125 typedef std::forward_iterator_tag iterator_category; 126 typedef std::ptrdiff_t difference_type; 127 128 redecl_iterator() : Current(0) { } 129 explicit redecl_iterator(decl_type *C) 130 : Current(C), Starter(C), PassedFirst(false) { } 131 132 reference operator*() const { return Current; } 133 pointer operator->() const { return Current; } 134 135 redecl_iterator& operator++() { 136 assert(Current && "Advancing while iterator has reached end"); 137 // Sanity check to avoid infinite loop on invalid redecl chain. 138 if (Current->isFirstDeclaration()) { 139 if (PassedFirst) { 140 assert(0 && "Passed first decl twice, invalid redecl chain!"); 141 Current = 0; 142 return *this; 143 } 144 PassedFirst = true; 145 } 146 147 // Get either previous decl or latest decl. 148 decl_type *Next = Current->RedeclLink.getNext(); 149 Current = (Next != Starter ? Next : 0); 150 return *this; 151 } 152 153 redecl_iterator operator++(int) { 154 redecl_iterator tmp(*this); 155 ++(*this); 156 return tmp; 157 } 158 159 friend bool operator==(redecl_iterator x, redecl_iterator y) { 160 return x.Current == y.Current; 161 } 162 friend bool operator!=(redecl_iterator x, redecl_iterator y) { 163 return x.Current != y.Current; 164 } 165 }; 166 167 /// \brief Returns iterator for all the redeclarations of the same decl. 168 /// It will iterate at least once (when this decl is the only one). 169 redecl_iterator redecls_begin() const { 170 return redecl_iterator(const_cast<decl_type*>( 171 static_cast<const decl_type*>(this))); 172 } 173 redecl_iterator redecls_end() const { return redecl_iterator(); } 174 175 friend class ASTDeclReader; 176 friend class ASTDeclWriter; 177 }; 178 179 } 180 181 #endif 182
