Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- ASTUnresolvedSet.h - Unresolved sets of declarations -----*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. //
  9. //  This file provides an UnresolvedSet-like class, whose contents are
  10. //  allocated using the allocator associated with an ASTContext.
  11. //
  12. //===----------------------------------------------------------------------===//
  13.  
  14. #ifndef LLVM_CLANG_AST_ASTUNRESOLVEDSET_H
  15. #define LLVM_CLANG_AST_ASTUNRESOLVEDSET_H
  16.  
  17. #include "clang/AST/ASTVector.h"
  18. #include "clang/AST/DeclAccessPair.h"
  19. #include "clang/AST/UnresolvedSet.h"
  20. #include "clang/Basic/Specifiers.h"
  21. #include <cassert>
  22. #include <cstdint>
  23.  
  24. namespace clang {
  25.  
  26. class NamedDecl;
  27.  
  28. /// An UnresolvedSet-like class which uses the ASTContext's allocator.
  29. class ASTUnresolvedSet {
  30.   friend class LazyASTUnresolvedSet;
  31.  
  32.   struct DeclsTy : ASTVector<DeclAccessPair> {
  33.     DeclsTy() = default;
  34.     DeclsTy(ASTContext &C, unsigned N) : ASTVector<DeclAccessPair>(C, N) {}
  35.  
  36.     bool isLazy() const { return getTag(); }
  37.     void setLazy(bool Lazy) { setTag(Lazy); }
  38.   };
  39.  
  40.   DeclsTy Decls;
  41.  
  42. public:
  43.   ASTUnresolvedSet() = default;
  44.   ASTUnresolvedSet(ASTContext &C, unsigned N) : Decls(C, N) {}
  45.  
  46.   using iterator = UnresolvedSetIterator;
  47.   using const_iterator = UnresolvedSetIterator;
  48.  
  49.   iterator begin() { return iterator(Decls.begin()); }
  50.   iterator end() { return iterator(Decls.end()); }
  51.  
  52.   const_iterator begin() const { return const_iterator(Decls.begin()); }
  53.   const_iterator end() const { return const_iterator(Decls.end()); }
  54.  
  55.   void addDecl(ASTContext &C, NamedDecl *D, AccessSpecifier AS) {
  56.     Decls.push_back(DeclAccessPair::make(D, AS), C);
  57.   }
  58.  
  59.   /// Replaces the given declaration with the new one, once.
  60.   ///
  61.   /// \return true if the set changed
  62.   bool replace(const NamedDecl *Old, NamedDecl *New, AccessSpecifier AS) {
  63.     for (DeclsTy::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
  64.       if (I->getDecl() == Old) {
  65.         I->set(New, AS);
  66.         return true;
  67.       }
  68.     }
  69.     return false;
  70.   }
  71.  
  72.   void erase(unsigned I) {
  73.     if (I == Decls.size() - 1)
  74.       Decls.pop_back();
  75.     else
  76.       Decls[I] = Decls.pop_back_val();
  77.   }
  78.  
  79.   void clear() { Decls.clear(); }
  80.  
  81.   bool empty() const { return Decls.empty(); }
  82.   unsigned size() const { return Decls.size(); }
  83.  
  84.   void reserve(ASTContext &C, unsigned N) {
  85.     Decls.reserve(C, N);
  86.   }
  87.  
  88.   void append(ASTContext &C, iterator I, iterator E) {
  89.     Decls.append(C, I.I, E.I);
  90.   }
  91.  
  92.   DeclAccessPair &operator[](unsigned I) { return Decls[I]; }
  93.   const DeclAccessPair &operator[](unsigned I) const { return Decls[I]; }
  94. };
  95.  
  96. /// An UnresolvedSet-like class that might not have been loaded from the
  97. /// external AST source yet.
  98. class LazyASTUnresolvedSet {
  99.   mutable ASTUnresolvedSet Impl;
  100.  
  101.   void getFromExternalSource(ASTContext &C) const;
  102.  
  103. public:
  104.   ASTUnresolvedSet &get(ASTContext &C) const {
  105.     if (Impl.Decls.isLazy())
  106.       getFromExternalSource(C);
  107.     return Impl;
  108.   }
  109.  
  110.   void reserve(ASTContext &C, unsigned N) { Impl.reserve(C, N); }
  111.  
  112.   void addLazyDecl(ASTContext &C, uintptr_t ID, AccessSpecifier AS) {
  113.     assert(Impl.empty() || Impl.Decls.isLazy());
  114.     Impl.Decls.setLazy(true);
  115.     Impl.addDecl(C, reinterpret_cast<NamedDecl *>(ID << 2), AS);
  116.   }
  117. };
  118.  
  119. } // namespace clang
  120.  
  121. #endif // LLVM_CLANG_AST_ASTUNRESOLVEDSET_H
  122.