Home | History | Annotate | Download | only in AST 
      1 //===--- Attr.h - Classes for representing attributes ----------*- 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/AST/AttrIterator.h"
     18 #include "clang/AST/Type.h"
     19 #include "clang/Basic/AttrKinds.h"
     20 #include "clang/Basic/LLVM.h"
     21 #include "clang/Basic/SourceLocation.h"
     22 #include "clang/Basic/VersionTuple.h"
     23 #include "llvm/ADT/SmallVector.h"
     24 #include "llvm/ADT/StringRef.h"
     25 #include "llvm/ADT/StringSwitch.h"
     26 #include "llvm/Support/ErrorHandling.h"
     27 #include "llvm/Support/raw_ostream.h"
     28 #include <cassert>
     29 #include <cstring>
     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 /// Attr - This represents one attribute.
     41 class Attr {
     42 private:
     43   SourceRange Range;
     44   unsigned AttrKind : 16;
     45 
     46 protected:
     47   /// An index into the spelling list of an
     48   /// attribute defined in Attr.td file.
     49   unsigned SpellingListIndex : 4;
     50 
     51   bool Inherited : 1;
     52 
     53   bool IsPackExpansion : 1;
     54 
     55   virtual ~Attr();
     56 
     57   void* operator new(size_t bytes) throw() {
     58     llvm_unreachable("Attrs cannot be allocated with regular 'new'.");
     59   }
     60   void operator delete(void* data) throw() {
     61     llvm_unreachable("Attrs cannot be released with regular 'delete'.");
     62   }
     63 
     64 public:
     65   // Forward so that the regular new and delete do not hide global ones.
     66   void* operator new(size_t Bytes, ASTContext &C,
     67                      size_t Alignment = 16) throw() {
     68     return ::operator new(Bytes, C, Alignment);
     69   }
     70   void operator delete(void *Ptr, ASTContext &C,
     71                        size_t Alignment) throw() {
     72     return ::operator delete(Ptr, C, Alignment);
     73   }
     74 
     75 protected:
     76   Attr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex = 0)
     77     : Range(R), AttrKind(AK), SpellingListIndex(SpellingListIndex),
     78       Inherited(false), IsPackExpansion(false) {}
     79 
     80 public:
     81 
     82   attr::Kind getKind() const {
     83     return static_cast<attr::Kind>(AttrKind);
     84   }
     85 
     86   unsigned getSpellingListIndex() const { return SpellingListIndex; }
     87 
     88   SourceLocation getLocation() const { return Range.getBegin(); }
     89   SourceRange getRange() const { return Range; }
     90   void setRange(SourceRange R) { Range = R; }
     91 
     92   bool isInherited() const { return Inherited; }
     93 
     94   void setPackExpansion(bool PE) { IsPackExpansion = PE; }
     95   bool isPackExpansion() const { return IsPackExpansion; }
     96 
     97   // Clone this attribute.
     98   virtual Attr *clone(ASTContext &C) const = 0;
     99 
    100   virtual bool isLateParsed() const { return false; }
    101 
    102   // Pretty print this attribute.
    103   virtual void printPretty(raw_ostream &OS,
    104                            const PrintingPolicy &Policy) const = 0;
    105 };
    106 
    107 class InheritableAttr : public Attr {
    108   virtual void anchor();
    109 protected:
    110   InheritableAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex = 0)
    111     : Attr(AK, R, SpellingListIndex) {}
    112 
    113 public:
    114   void setInherited(bool I) { Inherited = I; }
    115 
    116   // Implement isa/cast/dyncast/etc.
    117   static bool classof(const Attr *A) {
    118     return A->getKind() <= attr::LAST_INHERITABLE;
    119   }
    120 };
    121 
    122 class InheritableParamAttr : public InheritableAttr {
    123   virtual void anchor();
    124 protected:
    125   InheritableParamAttr(attr::Kind AK, SourceRange R,
    126                        unsigned SpellingListIndex = 0)
    127     : InheritableAttr(AK, R, SpellingListIndex) {}
    128 
    129 public:
    130   // Implement isa/cast/dyncast/etc.
    131   static bool classof(const Attr *A) {
    132     // Relies on relative order of enum emission with respect to MS inheritance
    133     // attrs.
    134     return A->getKind() <= attr::LAST_INHERITABLE_PARAM;
    135   }
    136 };
    137 
    138 class MSInheritanceAttr : public InheritableAttr {
    139   virtual void anchor();
    140 protected:
    141   MSInheritanceAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex = 0)
    142     : InheritableAttr(AK, R, SpellingListIndex) {}
    143 
    144 public:
    145   // Implement isa/cast/dyncast/etc.
    146   static bool classof(const Attr *A) {
    147     // Relies on relative order of enum emission with respect to param attrs.
    148     return (A->getKind() <= attr::LAST_MS_INHERITANCE &&
    149             A->getKind() > attr::LAST_INHERITABLE_PARAM);
    150   }
    151 };
    152 
    153 #include "clang/AST/Attrs.inc"
    154 
    155 }  // end namespace clang
    156 
    157 #endif
    158