LCOV - code coverage report
Current view: directory - gfx/angle/src/compiler - Types.h (source / functions) Found Hit Coverage
Test: app.info Lines: 136 0 0.0 %
Date: 2012-06-02 Functions: 48 0 0.0 %

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

Generated by: LCOV version 1.7