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

   1 //===--- Attr.h - Classes for representing expressions ----------*- 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 Attr interface and subclasses.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_AST_ATTR_H
  15 #define LLVM_CLANG_AST_ATTR_H
  16
  17 #include "clang/Basic/LLVM.h"
  18 #include "clang/Basic/AttrKinds.h"
  19 #include "clang/AST/Type.h"
  20 #include "clang/Basic/SourceLocation.h"
  21 #include "clang/Basic/VersionTuple.h"
  22 #include "llvm/ADT/SmallVector.h"
  23 #include "llvm/ADT/StringRef.h"
  24 #include "llvm/ADT/StringSwitch.h"
  25 #include "llvm/Support/ErrorHandling.h"
  26 #include "llvm/Support/raw_ostream.h"
  27 #include <cassert>
  28 #include <cstring>
  29 #include <algorithm>
  30
  31 namespace clang {
  32   class ASTContext;
  33   class IdentifierInfo;
  34   class ObjCInterfaceDecl;
  35   class Expr;
  36   class QualType;
  37   class FunctionDecl;
  38   class TypeSourceInfo;
  39 }
  40
  41 // Defined in ASTContext.h
  42 void *operator new(size_t Bytes, const clang::ASTContext &C,
  43                    size_t Alignment = 16);
  44 // FIXME: Being forced to not have a default argument here due to redeclaration
  45 //        rules on default arguments sucks
  46 void *operator new[](size_t Bytes, const clang::ASTContext &C,
  47                      size_t Alignment);
  48
  49 // It is good practice to pair new/delete operators.  Also, MSVC gives many
  50 // warnings if a matching delete overload is not declared, even though the
  51 // throw() spec guarantees it will not be implicitly called.
  52 void operator delete(void *Ptr, const clang::ASTContext &C, size_t);
  53 void operator delete[](void *Ptr, const clang::ASTContext &C, size_t);
  54
  55 namespace clang {
  56
  57 /// Attr - This represents one attribute.
  58 class Attr {
  59 private:
  60   SourceRange Range;
  61   unsigned AttrKind : 16;
  62
  63 protected:
  64   bool Inherited : 1;
  65
  66   virtual ~Attr();
  67
  68   void* operator new(size_t bytes) throw() {
  69     llvm_unreachable("Attrs cannot be allocated with regular 'new'.");
  70   }
  71   void operator delete(void* data) throw() {
  72     llvm_unreachable("Attrs cannot be released with regular 'delete'.");
  73   }
  74
  75 public:
  76   // Forward so that the regular new and delete do not hide global ones.
  77   void* operator new(size_t Bytes, ASTContext &C,
  78                      size_t Alignment = 16) throw() {
  79     return ::operator new(Bytes, C, Alignment);
  80   }
  81   void operator delete(void *Ptr, ASTContext &C,
  82                        size_t Alignment) throw() {
  83     return ::operator delete(Ptr, C, Alignment);
  84   }
  85
  86 protected:
  87   Attr(attr::Kind AK, SourceRange R)
  88     : Range(R), AttrKind(AK), Inherited(false) {}
  89
  90 public:
  91
  92   attr::Kind getKind() const {
  93     return static_cast<attr::Kind>(AttrKind);
  94   }
  95
  96   SourceLocation getLocation() const { return Range.getBegin(); }
  97   SourceRange getRange() const { return Range; }
  98   void setRange(SourceRange R) { Range = R; }
  99
 100   bool isInherited() const { return Inherited; }
 101
 102   // Clone this attribute.
 103   virtual Attr* clone(ASTContext &C) const = 0;
 104
 105   virtual bool isLateParsed() const { return false; }
 106
 107   // Pretty print this attribute.
 108   virtual void printPretty(llvm::raw_ostream &OS, ASTContext &C) const = 0;
 109
 110   // Implement isa/cast/dyncast/etc.
 111   static bool classof(const Attr *) { return true; }
 112 };
 113
 114 class InheritableAttr : public Attr {
 115   virtual void anchor();
 116 protected:
 117   InheritableAttr(attr::Kind AK, SourceRange R)
 118     : Attr(AK, R) {}
 119
 120 public:
 121   void setInherited(bool I) { Inherited = I; }
 122
 123   // Implement isa/cast/dyncast/etc.
 124   static bool classof(const Attr *A) {
 125     return A->getKind() <= attr::LAST_INHERITABLE;
 126   }
 127   static bool classof(const InheritableAttr *) { return true; }
 128 };
 129
 130 class InheritableParamAttr : public InheritableAttr {
 131   virtual void anchor();
 132 protected:
 133   InheritableParamAttr(attr::Kind AK, SourceRange R)
 134     : InheritableAttr(AK, R) {}
 135
 136 public:
 137   // Implement isa/cast/dyncast/etc.
 138   static bool classof(const Attr *A) {
 139     return A->getKind() <= attr::LAST_INHERITABLE_PARAM;
 140   }
 141   static bool classof(const InheritableParamAttr *) { return true; }
 142 };
 143
 144 #include "clang/AST/Attrs.inc"
 145
 146 /// AttrVec - A vector of Attr, which is how they are stored on the AST.
 147 typedef SmallVector<Attr*, 2> AttrVec;
 148 typedef SmallVector<const Attr*, 2> ConstAttrVec;
 149
 150 /// DestroyAttrs - Destroy the contents of an AttrVec.
 151 inline void DestroyAttrs (AttrVec& V, ASTContext &C) {
 152 }
 153
 154 /// specific_attr_iterator - Iterates over a subrange of an AttrVec, only
 155 /// providing attributes that are of a specifc type.
 156 template <typename SpecificAttr>
 157 class specific_attr_iterator {
 158   /// Current - The current, underlying iterator.
 159   /// In order to ensure we don't dereference an invalid iterator unless
 160   /// specifically requested, we don't necessarily advance this all the
 161   /// way. Instead, we advance it when an operation is requested; if the
 162   /// operation is acting on what should be a past-the-end iterator,
 163   /// then we offer no guarantees, but this way we do not dererence a
 164   /// past-the-end iterator when we move to a past-the-end position.
 165   mutable AttrVec::const_iterator Current;
 166
 167   void AdvanceToNext() const {
 168     while (!isa<SpecificAttr>(*Current))
 169       ++Current;
 170   }
 171
 172   void AdvanceToNext(AttrVec::const_iterator I) const {
 173     while (Current != I && !isa<SpecificAttr>(*Current))
 174       ++Current;
 175   }
 176
 177 public:
 178   typedef SpecificAttr*             value_type;
 179   typedef SpecificAttr*             reference;
 180   typedef SpecificAttr*             pointer;
 181   typedef std::forward_iterator_tag iterator_category;
 182   typedef std::ptrdiff_t            difference_type;
 183
 184   specific_attr_iterator() : Current() { }
 185   explicit specific_attr_iterator(AttrVec::const_iterator i) : Current(i) { }
 186
 187   reference operator*() const {
 188     AdvanceToNext();
 189     return cast<SpecificAttr>(*Current);
 190   }
 191   pointer operator->() const {
 192     AdvanceToNext();
 193     return cast<SpecificAttr>(*Current);
 194   }
 195
 196   specific_attr_iterator& operator++() {
 197     ++Current;
 198     return *this;
 199   }
 200   specific_attr_iterator operator++(int) {
 201     specific_attr_iterator Tmp(*this);
 202     ++(*this);
 203     return Tmp;
 204   }
 205
 206   friend bool operator==(specific_attr_iterator Left,
 207                          specific_attr_iterator Right) {
 208     if (Left.Current < Right.Current)
 209       Left.AdvanceToNext(Right.Current);
 210     else
 211       Right.AdvanceToNext(Left.Current);
 212     return Left.Current == Right.Current;
 213   }
 214   friend bool operator!=(specific_attr_iterator Left,
 215                          specific_attr_iterator Right) {
 216     return !(Left == Right);
 217   }
 218 };
 219
 220 template <typename T>
 221 inline specific_attr_iterator<T> specific_attr_begin(const AttrVec& vec) {
 222   return specific_attr_iterator<T>(vec.begin());
 223 }
 224 template <typename T>
 225 inline specific_attr_iterator<T> specific_attr_end(const AttrVec& vec) {
 226   return specific_attr_iterator<T>(vec.end());
 227 }
 228
 229 template <typename T>
 230 inline bool hasSpecificAttr(const AttrVec& vec) {
 231   return specific_attr_begin<T>(vec) != specific_attr_end<T>(vec);
 232 }
 233 template <typename T>
 234 inline T *getSpecificAttr(const AttrVec& vec) {
 235   specific_attr_iterator<T> i = specific_attr_begin<T>(vec);
 236   if (i != specific_attr_end<T>(vec))
 237     return *i;
 238   else
 239     return 0;
 240 }
 241
 242 /// getMaxAlignment - Returns the highest alignment value found among
 243 /// AlignedAttrs in an AttrVec, or 0 if there are none.
 244 inline unsigned getMaxAttrAlignment(const AttrVec& V, ASTContext &Ctx) {
 245   unsigned Align = 0;
 246   specific_attr_iterator<AlignedAttr> i(V.begin()), e(V.end());
 247   for(; i != e; ++i)
 248     Align = std::max(Align, i->getAlignment(Ctx));
 249   return Align;
 250 }
 251
 252 }  // end namespace clang
 253
 254 #endif