Attr.h revision 96329d4e07a9bcddb5a927892b70408c8fd8c474
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 <cassert> 18#include <string> 19 20namespace clang { 21 22/// Attr - This represents one attribute. 23class Attr { 24public: 25 enum Kind { 26 Alias, 27 Aligned, 28 Packed, 29 Annotate, 30 NoReturn, 31 Deprecated, 32 Weak, 33 DLLImport, 34 DLLExport, 35 NoThrow, 36 Format, 37 Visibility, 38 FastCall, 39 StdCall, 40 TransparentUnion, 41 IBOutletKind // Clang-specific. Use "Kind" suffix to not conflict with 42 // the IBOutlet macro. 43 }; 44 45private: 46 Attr *Next; 47 Kind AttrKind; 48 49protected: 50 Attr(Kind AK) : Next(0), AttrKind(AK) {} 51public: 52 virtual ~Attr() { 53 delete Next; 54 } 55 56 Kind getKind() const { return AttrKind; } 57 58 Attr *getNext() { return Next; } 59 const Attr *getNext() const { return Next; } 60 void setNext(Attr *next) { Next = next; } 61 62 void addAttr(Attr *attr) { 63 assert((attr != 0) && "addAttr(): attr is null"); 64 65 // FIXME: This doesn't preserve the order in any way. 66 attr->Next = Next; 67 Next = attr; 68 } 69 70 // Implement isa/cast/dyncast/etc. 71 static bool classof(const Attr *) { return true; } 72}; 73 74class PackedAttr : public Attr { 75public: 76 PackedAttr() : Attr(Packed) {} 77 78 // Implement isa/cast/dyncast/etc. 79 static bool classof(const Attr *A) { 80 return A->getKind() == Packed; 81 } 82 static bool classof(const PackedAttr *A) { return true; } 83}; 84 85class AlignedAttr : public Attr { 86 unsigned Alignment; 87public: 88 AlignedAttr(unsigned alignment) : Attr(Aligned), Alignment(alignment) {} 89 90 unsigned getAlignment() const { return Alignment; } 91 92 // Implement isa/cast/dyncast/etc. 93 static bool classof(const Attr *A) { 94 return A->getKind() == Aligned; 95 } 96 static bool classof(const AlignedAttr *A) { return true; } 97}; 98 99class AnnotateAttr : public Attr { 100 std::string Annotation; 101public: 102 AnnotateAttr(const std::string &ann) : Attr(Annotate), Annotation(ann) {} 103 104 const std::string& getAnnotation() const { return Annotation; } 105 106 // Implement isa/cast/dyncast/etc. 107 static bool classof(const Attr *A) { 108 return A->getKind() == Annotate; 109 } 110 static bool classof(const AnnotateAttr *A) { return true; } 111}; 112 113class AliasAttr : public Attr { 114 std::string Aliasee; 115public: 116 AliasAttr(const std::string &aliasee) : Attr(Alias), Aliasee(aliasee) {} 117 118 const std::string& getAliasee() const { return Aliasee; } 119 120 // Implement isa/cast/dyncast/etc. 121 122 static bool classof(const Attr *A) { return A->getKind() == Alias; } 123 static bool classof(const AliasAttr *A) { return true; } 124}; 125 126class IBOutletAttr : public Attr { 127public: 128 IBOutletAttr() : Attr(IBOutletKind) {} 129 130 // Implement isa/cast/dyncast/etc. 131 static bool classof(const Attr *A) { 132 return A->getKind() == IBOutletKind; 133 } 134 static bool classof(const IBOutletAttr *A) { return true; } 135}; 136 137class NoReturnAttr : public Attr { 138public: 139 NoReturnAttr() : Attr(NoReturn) {} 140 141 // Implement isa/cast/dyncast/etc. 142 143 static bool classof(const Attr *A) { return A->getKind() == NoReturn; } 144 static bool classof(const NoReturnAttr *A) { return true; } 145}; 146 147class DeprecatedAttr : public Attr { 148public: 149 DeprecatedAttr() : Attr(Deprecated) {} 150 151 // Implement isa/cast/dyncast/etc. 152 153 static bool classof(const Attr *A) { return A->getKind() == Deprecated; } 154 static bool classof(const DeprecatedAttr *A) { return true; } 155}; 156 157class WeakAttr : public Attr { 158public: 159 WeakAttr() : Attr(Weak) {} 160 161 // Implement isa/cast/dyncast/etc. 162 163 static bool classof(const Attr *A) { return A->getKind() == Weak; } 164 static bool classof(const WeakAttr *A) { return true; } 165}; 166 167class NoThrowAttr : public Attr { 168public: 169 NoThrowAttr() : Attr(NoThrow) {} 170 171 // Implement isa/cast/dyncast/etc. 172 173 static bool classof(const Attr *A) { return A->getKind() == NoThrow; } 174 static bool classof(const NoThrowAttr *A) { return true; } 175}; 176 177class FormatAttr : public Attr { 178 std::string Type; 179 int formatIdx, firstArg; 180public: 181 FormatAttr(const std::string &type, int idx, int first) : Attr(Format), 182 Type(type), formatIdx(idx), firstArg(first) {} 183 184 const std::string& getType() const { return Type; } 185 int getFormatIdx() const { return formatIdx; } 186 int getFirstArg() const { return firstArg; } 187 188 // Implement isa/cast/dyncast/etc. 189 190 static bool classof(const Attr *A) { return A->getKind() == Format; } 191 static bool classof(const FormatAttr *A) { return true; } 192}; 193 194class VisibilityAttr : public Attr { 195public: 196 /// @brief An enumeration for the kinds of visibility of symbols. 197 enum VisibilityTypes { 198 DefaultVisibility = 0, 199 HiddenVisibility, 200 ProtectedVisibility 201 }; 202private: 203 VisibilityTypes VisibilityType; 204public: 205 VisibilityAttr(VisibilityTypes v) : Attr(Visibility), 206 VisibilityType(v) {} 207 208 VisibilityTypes getVisibility() const { return VisibilityType; } 209 210 // Implement isa/cast/dyncast/etc. 211 212 static bool classof(const Attr *A) { return A->getKind() == Visibility; } 213 static bool classof(const VisibilityAttr *A) { return true; } 214}; 215 216class DLLImportAttr : public Attr { 217public: 218 DLLImportAttr() : Attr(DLLImport) {} 219 220 // Implement isa/cast/dyncast/etc. 221 222 static bool classof(const Attr *A) { return A->getKind() == DLLImport; } 223 static bool classof(const DLLImportAttr *A) { return true; } 224}; 225 226class DLLExportAttr : public Attr { 227public: 228 DLLExportAttr() : Attr(DLLExport) {} 229 230 // Implement isa/cast/dyncast/etc. 231 232 static bool classof(const Attr *A) { return A->getKind() == DLLExport; } 233 static bool classof(const DLLExportAttr *A) { return true; } 234}; 235 236class FastCallAttr : public Attr { 237public: 238 FastCallAttr() : Attr(FastCall) {} 239 240 // Implement isa/cast/dyncast/etc. 241 242 static bool classof(const Attr *A) { return A->getKind() == FastCall; } 243 static bool classof(const FastCallAttr *A) { return true; } 244}; 245 246class StdCallAttr : public Attr { 247public: 248 StdCallAttr() : Attr(StdCall) {} 249 250 // Implement isa/cast/dyncast/etc. 251 252 static bool classof(const Attr *A) { return A->getKind() == StdCall; } 253 static bool classof(const StdCallAttr *A) { return true; } 254}; 255 256class TransparentUnionAttr : public Attr { 257public: 258 TransparentUnionAttr() : Attr(TransparentUnion) {} 259 260 // Implement isa/cast/dyncast/etc. 261 262 static bool classof(const Attr *A) { return A->getKind() == TransparentUnion; } 263 static bool classof(const TransparentUnionAttr *A) { return true; } 264}; 265 266} // end namespace clang 267 268#endif 269