src/third_party/angle/src/compiler/translator/Types.h

   1 //
   2 // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5 //
   6
   7 #ifndef _TYPES_INCLUDED
   8 #define _TYPES_INCLUDED
   9
  10 #include "common/angleutils.h"
  11
  12 #include "compiler/translator/BaseTypes.h"
  13 #include "compiler/translator/Common.h"
  14 #include "compiler/translator/compilerdebug.h"
  15
  16 struct TPublicType;
  17 class TType;
  18
  19 class TField
  20 {
  21 public:
  22     POOL_ALLOCATOR_NEW_DELETE();
  23     TField(TType* type, TString* name) : mType(type), mName(name) {}
  24
  25     // TODO(alokp): We should only return const type.
  26     // Fix it by tweaking grammar.
  27     TType* type() { return mType; }
  28     const TType* type() const { return mType; }
  29
  30     const TString& name() const { return *mName; }
  31
  32 private:
  33     DISALLOW_COPY_AND_ASSIGN(TField);
  34     TType* mType;
  35     TString* mName;
  36 };
  37
  38 typedef TVector<TField*> TFieldList;
  39 inline TFieldList* NewPoolTFieldList()
  40 {
  41     void* memory = GetGlobalPoolAllocator()->allocate(sizeof(TFieldList));
  42     return new(memory) TFieldList;
  43 }
  44
  45 class TStructure
  46 {
  47 public:
  48     POOL_ALLOCATOR_NEW_DELETE();
  49     TStructure(TString* name, TFieldList* fields)
  50         : mName(name),
  51           mFields(fields),
  52           mObjectSize(0),
  53           mDeepestNesting(0) {
  54     }
  55
  56     const TString& name() const { return *mName; }
  57     const TFieldList& fields() const { return *mFields; }
  58
  59     const TString& mangledName() const {
  60         if (mMangledName.empty())
  61             mMangledName = buildMangledName();
  62         return mMangledName;
  63     }
  64     size_t objectSize() const {
  65         if (mObjectSize == 0)
  66             mObjectSize = calculateObjectSize();
  67         return mObjectSize;
  68     };
  69     int deepestNesting() const {
  70         if (mDeepestNesting == 0)
  71             mDeepestNesting = calculateDeepestNesting();
  72         return mDeepestNesting;
  73     }
  74     bool containsArrays() const;
  75
  76 private:
  77     DISALLOW_COPY_AND_ASSIGN(TStructure);
  78     TString buildMangledName() const;
  79     size_t calculateObjectSize() const;
  80     int calculateDeepestNesting() const;
  81
  82     TString* mName;
  83     TFieldList* mFields;
  84
  85     mutable TString mMangledName;
  86     mutable size_t mObjectSize;
  87     mutable int mDeepestNesting;
  88 };
  89
  90 //
  91 // Base class for things that have a type.
  92 //
  93 class TType
  94 {
  95 public:
  96     POOL_ALLOCATOR_NEW_DELETE();
  97     TType() {}
  98     TType(TBasicType t, TPrecision p, TQualifier q = EvqTemporary, unsigned char s = 1, bool m = false, bool a = false) :
  99             type(t), precision(p), qualifier(q), size(s), matrix(m), array(a), arraySize(0), structure(0)
 100     {
 101     }
 102     explicit TType(const TPublicType &p);
 103     TType(TStructure* userDef, TPrecision p = EbpUndefined) :
 104             type(EbtStruct), precision(p), qualifier(EvqTemporary), size(1), matrix(false), array(false), arraySize(0), structure(userDef)
 105     {
 106     }
 107
 108     TBasicType getBasicType() const { return type; }
 109     void setBasicType(TBasicType t) { type = t; }
 110
 111     TPrecision getPrecision() const { return precision; }
 112     void setPrecision(TPrecision p) { precision = p; }
 113
 114     TQualifier getQualifier() const { return qualifier; }
 115     void setQualifier(TQualifier q) { qualifier = q; }
 116
 117     // One-dimensional size of single instance type
 118     int getNominalSize() const { return size; }
 119     void setNominalSize(unsigned char s) { size = s; }
 120     // Full size of single instance of type
 121     size_t getObjectSize() const;
 122
 123     int elementRegisterCount() const
 124     {
 125         if (structure)
 126         {
 127             const TFieldList &fields = getStruct()->fields();
 128             int registerCount = 0;
 129
 130             for (size_t i = 0; i < fields.size(); i++)
 131             {
 132                 registerCount += fields[i]->type()->totalRegisterCount();
 133             }
 134
 135             return registerCount;
 136         }
 137         else if (isMatrix())
 138         {
 139             return getNominalSize();
 140         }
 141         else
 142         {
 143             return 1;
 144         }
 145     }
 146
 147     int totalRegisterCount() const
 148     {
 149         if (array)
 150         {
 151             return arraySize * elementRegisterCount();
 152         }
 153         else
 154         {
 155             return elementRegisterCount();
 156         }
 157     }
 158
 159     bool isMatrix() const { return matrix ? true : false; }
 160     void setMatrix(bool m) { matrix = m; }
 161
 162     bool isArray() const  { return array ? true : false; }
 163     int getArraySize() const { return arraySize; }
 164     void setArraySize(int s) { array = true; arraySize = s; }
 165     void clearArrayness() { array = false; arraySize = 0; }
 166
 167     bool isVector() const { return size > 1 && !matrix; }
 168     bool isScalar() const { return size == 1 && !matrix && !structure; }
 169
 170     TStructure* getStruct() const { return structure; }
 171     void setStruct(TStructure* s) { structure = s; }
 172
 173     const TString& getMangledName() const {
 174         if (mangled.empty()) {
 175             mangled = buildMangledName();
 176             mangled += ';';
 177         }
 178         return mangled;
 179     }
 180
 181     bool sameElementType(const TType& right) const {
 182         return      type == right.type   &&
 183                     size == right.size   &&
 184                   matrix == right.matrix &&
 185                structure == right.structure;
 186     }
 187     bool operator==(const TType& right) const {
 188         return      type == right.type   &&
 189                     size == right.size   &&
 190                   matrix == right.matrix &&
 191                    array == right.array  && (!array || arraySize == right.arraySize) &&
 192                structure == right.structure;
 193         // don't check the qualifier, it's not ever what's being sought after
 194     }
 195     bool operator!=(const TType& right) const {
 196         return !operator==(right);
 197     }
 198     bool operator<(const TType& right) const {
 199         if (type != right.type) return type < right.type;
 200         if (size != right.size) return size < right.size;
 201         if (matrix != right.matrix) return matrix < right.matrix;
 202         if (array != right.array) return array < right.array;
 203         if (arraySize != right.arraySize) return arraySize < right.arraySize;
 204         if (structure != right.structure) return structure < right.structure;
 205
 206         return false;
 207     }
 208
 209     const char* getBasicString() const { return ::getBasicString(type); }
 210     const char* getPrecisionString() const { return ::getPrecisionString(precision); }
 211     const char* getQualifierString() const { return ::getQualifierString(qualifier); }
 212     TString getCompleteString() const;
 213
 214     // If this type is a struct, returns the deepest struct nesting of
 215     // any field in the struct. For example:
 216     //   struct nesting1 {
 217     //     vec4 position;
 218     //   };
 219     //   struct nesting2 {
 220     //     nesting1 field1;
 221     //     vec4 field2;
 222     //   };
 223     // For type "nesting2", this method would return 2 -- the number
 224     // of structures through which indirection must occur to reach the
 225     // deepest field (nesting2.field1.position).
 226     int getDeepestStructNesting() const {
 227         return structure ? structure->deepestNesting() : 0;
 228     }
 229
 230     bool isStructureContainingArrays() const {
 231         return structure ? structure->containsArrays() : false;
 232     }
 233
 234 private:
 235     TString buildMangledName() const;
 236
 237     TBasicType type;
 238     TPrecision precision;
 239     TQualifier qualifier;
 240     unsigned char size;
 241     bool matrix;
 242     bool array;
 243     int arraySize;
 244
 245     TStructure* structure;      // 0 unless this is a struct
 246
 247     mutable TString mangled;
 248 };
 249
 250 //
 251 // This is a workaround for a problem with the yacc stack,  It can't have
 252 // types that it thinks have non-trivial constructors.  It should
 253 // just be used while recognizing the grammar, not anything else.  Pointers
 254 // could be used, but also trying to avoid lots of memory management overhead.
 255 //
 256 // Not as bad as it looks, there is no actual assumption that the fields
 257 // match up or are name the same or anything like that.
 258 //
 259 struct TPublicType
 260 {
 261     TBasicType type;
 262     TQualifier qualifier;
 263     TPrecision precision;
 264     unsigned char size;          // size of vector or matrix, not size of array
 265     bool matrix;
 266     bool array;
 267     int arraySize;
 268     TType* userDef;
 269     TSourceLoc line;
 270
 271     void setBasic(TBasicType bt, TQualifier q, const TSourceLoc& ln)
 272     {
 273         type = bt;
 274         qualifier = q;
 275         precision = EbpUndefined;
 276         size = 1;
 277         matrix = false;
 278         array = false;
 279         arraySize = 0;
 280         userDef = 0;
 281         line = ln;
 282     }
 283
 284     void setAggregate(unsigned char s, bool m = false)
 285     {
 286         size = s;
 287         matrix = m;
 288     }
 289
 290     void setArray(bool a, int s = 0)
 291     {
 292         array = a;
 293         arraySize = s;
 294     }
 295
 296     bool isStructureContainingArrays() const
 297     {
 298         if (!userDef)
 299         {
 300             return false;
 301         }
 302
 303         return userDef->isStructureContainingArrays();
 304     }
 305 };
 306
 307 #endif // _TYPES_INCLUDED_