code.vuplus.com Git - vuplus_webkit/blob - Source/ThirdParty/ANGLE/src/compiler/Types.h

   1 //
   2 // Copyright (c) 2002-2010 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 "compiler/BaseTypes.h"
  11 #include "compiler/Common.h"
  12 #include "compiler/debug.h"
  13
  14 //
  15 // Need to have association of line numbers to types in a list for building structs.
  16 //
  17 class TType;
  18 struct TTypeLine {
  19     TType* type;
  20     int line;
  21 };
  22 typedef TVector<TTypeLine> TTypeList;
  23
  24 inline TTypeList* NewPoolTTypeList()
  25 {
  26     void* memory = GlobalPoolAllocator.allocate(sizeof(TTypeList));
  27     return new(memory) TTypeList;
  28 }
  29
  30 //
  31 // This is a workaround for a problem with the yacc stack,  It can't have
  32 // types that it thinks have non-trivial constructors.  It should
  33 // just be used while recognizing the grammar, not anything else.  Pointers
  34 // could be used, but also trying to avoid lots of memory management overhead.
  35 //
  36 // Not as bad as it looks, there is no actual assumption that the fields
  37 // match up or are name the same or anything like that.
  38 //
  39 class TPublicType {
  40 public:
  41     TBasicType type;
  42     TQualifier qualifier;
  43     TPrecision precision;
  44     int size;          // size of vector or matrix, not size of array
  45     bool matrix;
  46     bool array;
  47     int arraySize;
  48     TType* userDef;
  49     int line;
  50
  51     void setBasic(TBasicType bt, TQualifier q, int ln = 0)
  52     {
  53         type = bt;
  54         qualifier = q;
  55         precision = EbpUndefined;
  56         size = 1;
  57         matrix = false;
  58         array = false;
  59         arraySize = 0;
  60         userDef = 0;
  61         line = ln;
  62     }
  63
  64     void setAggregate(int s, bool m = false)
  65     {
  66         size = s;
  67         matrix = m;
  68     }
  69
  70     void setArray(bool a, int s = 0)
  71     {
  72         array = a;
  73         arraySize = s;
  74     }
  75 };
  76
  77 typedef TMap<TTypeList*, TTypeList*> TStructureMap;
  78 typedef TMap<TTypeList*, TTypeList*>::iterator TStructureMapIterator;
  79 //
  80 // Base class for things that have a type.
  81 //
  82 class TType {
  83 public:
  84     POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator)
  85     TType() {}
  86     TType(TBasicType t, TPrecision p, TQualifier q = EvqTemporary, int s = 1, bool m = false, bool a = false) :
  87             type(t), precision(p), qualifier(q), size(s), matrix(m), array(a), arraySize(0),
  88             maxArraySize(0), arrayInformationType(0), structure(0), structureSize(0), fieldName(0), mangled(0), typeName(0)
  89     {
  90     }
  91     explicit TType(const TPublicType &p) :
  92             type(p.type), precision(p.precision), qualifier(p.qualifier), size(p.size), matrix(p.matrix), array(p.array), arraySize(p.arraySize),
  93             maxArraySize(0), arrayInformationType(0), structure(0), structureSize(0), fieldName(0), mangled(0), typeName(0)
  94     {
  95         if (p.userDef) {
  96             structure = p.userDef->getStruct();
  97             typeName = NewPoolTString(p.userDef->getTypeName().c_str());
  98         }
  99     }
 100     TType(TTypeList* userDef, const TString& n, TPrecision p = EbpUndefined) :
 101             type(EbtStruct), precision(p), qualifier(EvqTemporary), size(1), matrix(false), array(false), arraySize(0),
 102             maxArraySize(0), arrayInformationType(0), structure(userDef), structureSize(0), fieldName(0), mangled(0)
 103     {
 104         typeName = NewPoolTString(n.c_str());
 105     }
 106
 107     void copyType(const TType& copyOf, TStructureMap& remapper)
 108     {
 109         type = copyOf.type;
 110         precision = copyOf.precision;
 111         qualifier = copyOf.qualifier;
 112         size = copyOf.size;
 113         matrix = copyOf.matrix;
 114         array = copyOf.array;
 115         arraySize = copyOf.arraySize;
 116
 117         TStructureMapIterator iter;
 118         if (copyOf.structure) {
 119             if ((iter = remapper.find(structure)) == remapper.end()) {
 120                 // create the new structure here
 121                 structure = NewPoolTTypeList();
 122                 for (unsigned int i = 0; i < copyOf.structure->size(); ++i) {
 123                     TTypeLine typeLine;
 124                     typeLine.line = (*copyOf.structure)[i].line;
 125                     typeLine.type = (*copyOf.structure)[i].type->clone(remapper);
 126                     structure->push_back(typeLine);
 127                 }
 128             } else {
 129                 structure = iter->second;
 130             }
 131         } else
 132             structure = 0;
 133
 134         fieldName = 0;
 135         if (copyOf.fieldName)
 136             fieldName = NewPoolTString(copyOf.fieldName->c_str());
 137         typeName = 0;
 138         if (copyOf.typeName)
 139             typeName = NewPoolTString(copyOf.typeName->c_str());
 140
 141         mangled = 0;
 142         if (copyOf.mangled)
 143             mangled = NewPoolTString(copyOf.mangled->c_str());
 144
 145         structureSize = copyOf.structureSize;
 146         maxArraySize = copyOf.maxArraySize;
 147         assert(copyOf.arrayInformationType == 0);
 148         arrayInformationType = 0; // arrayInformationType should not be set for builtIn symbol table level
 149     }
 150
 151     TType* clone(TStructureMap& remapper)
 152     {
 153         TType *newType = new TType();
 154         newType->copyType(*this, remapper);
 155
 156         return newType;
 157     }
 158
 159     TBasicType getBasicType() const { return type; }
 160     void setBasicType(TBasicType t) { type = t; }
 161
 162     TPrecision getPrecision() const { return precision; }
 163     void setPrecision(TPrecision p) { precision = p; }
 164
 165     TQualifier getQualifier() const { return qualifier; }
 166     void setQualifier(TQualifier q) { qualifier = q; }
 167
 168     // One-dimensional size of single instance type
 169     int getNominalSize() const { return size; }
 170     void setNominalSize(int s) { size = s; }
 171     // Full size of single instance of type
 172     int getObjectSize() const
 173     {
 174         int totalSize;
 175
 176         if (getBasicType() == EbtStruct)
 177             totalSize = getStructSize();
 178         else if (matrix)
 179             totalSize = size * size;
 180         else
 181             totalSize = size;
 182
 183         if (isArray())
 184             totalSize *= std::max(getArraySize(), getMaxArraySize());
 185
 186         return totalSize;
 187     }
 188
 189     bool isMatrix() const { return matrix ? true : false; }
 190     void setMatrix(bool m) { matrix = m; }
 191
 192     bool isArray() const  { return array ? true : false; }
 193     int getArraySize() const { return arraySize; }
 194     void setArraySize(int s) { array = true; arraySize = s; }
 195     int getMaxArraySize () const { return maxArraySize; }
 196     void setMaxArraySize (int s) { maxArraySize = s; }
 197     void clearArrayness() { array = false; arraySize = 0; maxArraySize = 0; }
 198     void setArrayInformationType(TType* t) { arrayInformationType = t; }
 199     TType* getArrayInformationType() const { return arrayInformationType; }
 200
 201     bool isVector() const { return size > 1 && !matrix; }
 202     bool isScalar() const { return size == 1 && !matrix && !structure; }
 203
 204     TTypeList* getStruct() const { return structure; }
 205     void setStruct(TTypeList* s) { structure = s; }
 206
 207     const TString& getTypeName() const
 208     {
 209         assert(typeName);
 210         return *typeName;
 211     }
 212     void setTypeName(const TString& n)
 213     {
 214         typeName = NewPoolTString(n.c_str());
 215     }
 216
 217     bool isField() const { return fieldName != 0; }
 218     const TString& getFieldName() const
 219     {
 220         assert(fieldName);
 221         return *fieldName;
 222     }
 223     void setFieldName(const TString& n)
 224     {
 225         fieldName = NewPoolTString(n.c_str());
 226     }
 227
 228     TString& getMangledName() {
 229         if (!mangled) {
 230             mangled = NewPoolTString("");
 231             buildMangledName(*mangled);
 232             *mangled += ';' ;
 233         }
 234
 235         return *mangled;
 236     }
 237
 238     bool sameElementType(const TType& right) const {
 239         return      type == right.type   &&
 240                     size == right.size   &&
 241                   matrix == right.matrix &&
 242                structure == right.structure;
 243     }
 244     bool operator==(const TType& right) const {
 245         return      type == right.type   &&
 246                     size == right.size   &&
 247                   matrix == right.matrix &&
 248                    array == right.array  && (!array || arraySize == right.arraySize) &&
 249                structure == right.structure;
 250         // don't check the qualifier, it's not ever what's being sought after
 251     }
 252     bool operator!=(const TType& right) const {
 253         return !operator==(right);
 254     }
 255     bool operator<(const TType& right) const {
 256         if (type != right.type) return type < right.type;
 257         if (size != right.size) return size < right.size;
 258         if (matrix != right.matrix) return matrix < right.matrix;
 259         if (array != right.array) return array < right.array;
 260         if (arraySize != right.arraySize) return arraySize < right.arraySize;
 261         if (structure != right.structure) return structure < right.structure;
 262
 263         return false;
 264     }
 265
 266     const char* getBasicString() const { return ::getBasicString(type); }
 267     const char* getPrecisionString() const { return ::getPrecisionString(precision); }
 268     const char* getQualifierString() const { return ::getQualifierString(qualifier); }
 269     TString getCompleteString() const;
 270
 271 protected:
 272     void buildMangledName(TString&);
 273     int getStructSize() const;
 274
 275     TBasicType type      : 6;
 276     TPrecision precision;
 277     TQualifier qualifier : 7;
 278     int size             : 8; // size of vector or matrix, not size of array
 279     unsigned int matrix  : 1;
 280     unsigned int array   : 1;
 281     int arraySize;
 282     int maxArraySize;
 283     TType* arrayInformationType;
 284
 285     TTypeList* structure;      // 0 unless this is a struct
 286     mutable int structureSize;
 287
 288     TString *fieldName;         // for structure field names
 289     TString *mangled;
 290     TString *typeName;          // for structure field type name
 291 };
 292
 293 #endif // _TYPES_INCLUDED_