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

   1 //===--- DeclGroup.h - Classes for representing groups of Decls -*- 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 DeclGroup, DeclGroupRef, and OwningDeclGroup classes.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_AST_DECLGROUP_H
  15 #define LLVM_CLANG_AST_DECLGROUP_H
  16
  17 #include "llvm/System/DataTypes.h"
  18 #include <cassert>
  19
  20 namespace clang {
  21
  22 class ASTContext;
  23 class Decl;
  24 class DeclGroup;
  25 class DeclGroupIterator;
  26
  27 class DeclGroup {
  28   // FIXME: Include a TypeSpecifier object.
  29   unsigned NumDecls;
  30
  31 private:
  32   DeclGroup() : NumDecls(0) {}
  33   DeclGroup(unsigned numdecls, Decl** decls);
  34
  35 public:
  36   static DeclGroup *Create(ASTContext &C, Decl **Decls, unsigned NumDecls);
  37   void Destroy(ASTContext& C);
  38
  39   unsigned size() const { return NumDecls; }
  40
  41   Decl*& operator[](unsigned i) {
  42     assert (i < NumDecls && "Out-of-bounds access.");
  43     return *((Decl**) (this+1));
  44   }
  45
  46   Decl* const& operator[](unsigned i) const {
  47     assert (i < NumDecls && "Out-of-bounds access.");
  48     return *((Decl* const*) (this+1));
  49   }
  50 };
  51
  52 class DeclGroupRef {
  53   // Note this is not a PointerIntPair because we need the address of the
  54   // non-group case to be valid as a Decl** for iteration.
  55   enum Kind { SingleDeclKind=0x0, DeclGroupKind=0x1, Mask=0x1 };
  56   Decl* D;
  57
  58   Kind getKind() const {
  59     return (Kind) (reinterpret_cast<uintptr_t>(D) & Mask);
  60   }
  61
  62 public:
  63   DeclGroupRef() : D(0) {}
  64
  65   explicit DeclGroupRef(Decl* d) : D(d) {}
  66   explicit DeclGroupRef(DeclGroup* dg)
  67     : D((Decl*) (reinterpret_cast<uintptr_t>(dg) | DeclGroupKind)) {}
  68
  69   static DeclGroupRef Create(ASTContext &C, Decl **Decls, unsigned NumDecls) {
  70     if (NumDecls == 0)
  71       return DeclGroupRef();
  72     if (NumDecls == 1)
  73       return DeclGroupRef(Decls[0]);
  74     return DeclGroupRef(DeclGroup::Create(C, Decls, NumDecls));
  75   }
  76
  77   typedef Decl** iterator;
  78   typedef Decl* const * const_iterator;
  79
  80   bool isNull() const { return D == 0; }
  81   bool isSingleDecl() const { return getKind() == SingleDeclKind; }
  82   bool isDeclGroup() const { return getKind() == DeclGroupKind; }
  83
  84   Decl *getSingleDecl() {
  85     assert(isSingleDecl() && "Isn't a declgroup");
  86     return D;
  87   }
  88   const Decl *getSingleDecl() const {
  89     return const_cast<DeclGroupRef*>(this)->getSingleDecl();
  90   }
  91
  92   DeclGroup &getDeclGroup() {
  93     assert(isDeclGroup() && "Isn't a declgroup");
  94     return *((DeclGroup*)(reinterpret_cast<uintptr_t>(D) & ~Mask));
  95   }
  96   const DeclGroup &getDeclGroup() const {
  97     return const_cast<DeclGroupRef*>(this)->getDeclGroup();
  98   }
  99
 100   iterator begin() {
 101     if (isSingleDecl())
 102       return D ? &D : 0;
 103     return &getDeclGroup()[0];
 104   }
 105
 106   iterator end() {
 107     if (isSingleDecl())
 108       return D ? &D+1 : 0;
 109     DeclGroup &G = getDeclGroup();
 110     return &G[0] + G.size();
 111   }
 112
 113   const_iterator begin() const {
 114     if (isSingleDecl())
 115       return D ? &D : 0;
 116     return &getDeclGroup()[0];
 117   }
 118
 119   const_iterator end() const {
 120     if (isSingleDecl())
 121       return D ? &D+1 : 0;
 122     const DeclGroup &G = getDeclGroup();
 123     return &G[0] + G.size();
 124   }
 125
 126   void *getAsOpaquePtr() const { return D; }
 127   static DeclGroupRef getFromOpaquePtr(void *Ptr) {
 128     DeclGroupRef X;
 129     X.D = static_cast<Decl*>(Ptr);
 130     return X;
 131   }
 132 };
 133
 134 } // end clang namespace
 135
 136 namespace llvm {
 137   // DeclGroupRef is "like a pointer", implement PointerLikeTypeTraits.
 138   template <typename T>
 139   class PointerLikeTypeTraits;
 140   template <>
 141   class PointerLikeTypeTraits<clang::DeclGroupRef> {
 142   public:
 143     static inline void *getAsVoidPointer(clang::DeclGroupRef P) {
 144       return P.getAsOpaquePtr();
 145     }
 146     static inline clang::DeclGroupRef getFromVoidPointer(void *P) {
 147       return clang::DeclGroupRef::getFromOpaquePtr(P);
 148     }
 149     enum { NumLowBitsAvailable = 0 };
 150   };
 151 }
 152 #endif