daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1 | // |
shannon.woods%transgaming.com@gtempaccount.com | 6f273e3 | 2013-04-13 03:41:15 +0000 | [diff] [blame] | 2 | // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved. |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 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 | |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 10 | #include "common/angleutils.h" |
| 11 | |
Geoff Lang | 1773282 | 2013-08-29 13:46:49 -0400 | [diff] [blame] | 12 | #include "compiler/translator/BaseTypes.h" |
| 13 | #include "compiler/translator/Common.h" |
| 14 | #include "compiler/translator/compilerdebug.h" |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 15 | |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 16 | struct TPublicType; |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 17 | class TType; |
Jamie Madill | bfa91f4 | 2014-06-05 15:45:18 -0400 | [diff] [blame] | 18 | class TSymbol; |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 19 | |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 20 | class TField |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 21 | { |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 22 | public: |
Alok Priyadarshi | 8156b6b | 2013-09-23 14:56:58 -0400 | [diff] [blame] | 23 | POOL_ALLOCATOR_NEW_DELETE(); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 24 | TField(TType *type, TString *name, const TSourceLoc &line) |
| 25 | : mType(type), |
| 26 | mName(name), |
| 27 | mLine(line) |
| 28 | { |
| 29 | } |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 30 | |
| 31 | // TODO(alokp): We should only return const type. |
| 32 | // Fix it by tweaking grammar. |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 33 | TType *type() |
| 34 | { |
| 35 | return mType; |
| 36 | } |
| 37 | const TType *type() const |
| 38 | { |
| 39 | return mType; |
| 40 | } |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 41 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 42 | const TString &name() const |
| 43 | { |
| 44 | return *mName; |
| 45 | } |
| 46 | const TSourceLoc &line() const |
| 47 | { |
| 48 | return mLine; |
| 49 | } |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 50 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 51 | private: |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 52 | DISALLOW_COPY_AND_ASSIGN(TField); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 53 | TType *mType; |
| 54 | TString *mName; |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 55 | TSourceLoc mLine; |
| 56 | }; |
| 57 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 58 | typedef TVector<TField *> TFieldList; |
| 59 | inline TFieldList *NewPoolTFieldList() |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 60 | { |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 61 | void *memory = GetGlobalPoolAllocator()->allocate(sizeof(TFieldList)); |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 62 | return new(memory) TFieldList; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 63 | } |
| 64 | |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 65 | class TFieldListCollection |
| 66 | { |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 67 | public: |
| 68 | const TString &name() const |
| 69 | { |
| 70 | return *mName; |
| 71 | } |
| 72 | const TFieldList &fields() const |
| 73 | { |
| 74 | return *mFields; |
| 75 | } |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 76 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 77 | const TString &mangledName() const |
| 78 | { |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 79 | if (mMangledName.empty()) |
| 80 | mMangledName = buildMangledName(); |
| 81 | return mMangledName; |
| 82 | } |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 83 | size_t objectSize() const |
| 84 | { |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 85 | if (mObjectSize == 0) |
| 86 | mObjectSize = calculateObjectSize(); |
| 87 | return mObjectSize; |
| 88 | }; |
| 89 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 90 | protected: |
| 91 | TFieldListCollection(const TString *name, TFieldList *fields) |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 92 | : mName(name), |
| 93 | mFields(fields), |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 94 | mObjectSize(0) |
| 95 | { |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 96 | } |
| 97 | TString buildMangledName() const; |
| 98 | size_t calculateObjectSize() const; |
| 99 | virtual TString mangledNamePrefix() const = 0; |
| 100 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 101 | const TString *mName; |
| 102 | TFieldList *mFields; |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 103 | |
| 104 | mutable TString mMangledName; |
| 105 | mutable size_t mObjectSize; |
| 106 | }; |
| 107 | |
| 108 | // May also represent interface blocks |
| 109 | class TStructure : public TFieldListCollection |
| 110 | { |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 111 | public: |
Alok Priyadarshi | 8156b6b | 2013-09-23 14:56:58 -0400 | [diff] [blame] | 112 | POOL_ALLOCATOR_NEW_DELETE(); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 113 | TStructure(const TString *name, TFieldList *fields) |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 114 | : TFieldListCollection(name, fields), |
Jamie Madill | bfa91f4 | 2014-06-05 15:45:18 -0400 | [diff] [blame] | 115 | mDeepestNesting(0), |
| 116 | mUniqueId(0) |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 117 | { |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 118 | } |
| 119 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 120 | int deepestNesting() const |
| 121 | { |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 122 | if (mDeepestNesting == 0) |
| 123 | mDeepestNesting = calculateDeepestNesting(); |
| 124 | return mDeepestNesting; |
| 125 | } |
| 126 | bool containsArrays() const; |
| 127 | |
Zhenyao Mo | c8f7232 | 2014-05-13 15:21:37 -0700 | [diff] [blame] | 128 | bool equals(const TStructure &other) const; |
| 129 | |
Jamie Madill | bfa91f4 | 2014-06-05 15:45:18 -0400 | [diff] [blame] | 130 | void setUniqueId(int uniqueId) |
| 131 | { |
| 132 | mUniqueId = uniqueId; |
| 133 | } |
| 134 | |
| 135 | int uniqueId() const |
| 136 | { |
| 137 | ASSERT(mUniqueId != 0); |
| 138 | return mUniqueId; |
| 139 | } |
| 140 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 141 | private: |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 142 | DISALLOW_COPY_AND_ASSIGN(TStructure); |
Zhenyao Mo | e740add | 2014-07-18 17:01:01 -0700 | [diff] [blame] | 143 | |
| 144 | // TODO(zmo): Find a way to get rid of the const_cast in function |
| 145 | // setName(). At the moment keep this function private so only |
| 146 | // friend class RegenerateStructNames may call it. |
| 147 | friend class RegenerateStructNames; |
| 148 | void setName(const TString &name) |
| 149 | { |
| 150 | TString *mutableName = const_cast<TString *>(mName); |
| 151 | *mutableName = name; |
| 152 | } |
| 153 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 154 | virtual TString mangledNamePrefix() const |
| 155 | { |
| 156 | return "struct-"; |
| 157 | } |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 158 | int calculateDeepestNesting() const; |
| 159 | |
| 160 | mutable int mDeepestNesting; |
Jamie Madill | bfa91f4 | 2014-06-05 15:45:18 -0400 | [diff] [blame] | 161 | int mUniqueId; |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 162 | }; |
| 163 | |
| 164 | class TInterfaceBlock : public TFieldListCollection |
| 165 | { |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 166 | public: |
Alok Priyadarshi | 8156b6b | 2013-09-23 14:56:58 -0400 | [diff] [blame] | 167 | POOL_ALLOCATOR_NEW_DELETE(); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 168 | TInterfaceBlock(const TString *name, TFieldList *fields, const TString *instanceName, |
| 169 | int arraySize, const TLayoutQualifier &layoutQualifier) |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 170 | : TFieldListCollection(name, fields), |
| 171 | mInstanceName(instanceName), |
| 172 | mArraySize(arraySize), |
| 173 | mBlockStorage(layoutQualifier.blockStorage), |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 174 | mMatrixPacking(layoutQualifier.matrixPacking) |
| 175 | { |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 176 | } |
| 177 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 178 | const TString &instanceName() const |
| 179 | { |
| 180 | return *mInstanceName; |
| 181 | } |
| 182 | bool hasInstanceName() const |
| 183 | { |
| 184 | return mInstanceName != NULL; |
| 185 | } |
| 186 | bool isArray() const |
| 187 | { |
| 188 | return mArraySize > 0; |
| 189 | } |
| 190 | int arraySize() const |
| 191 | { |
| 192 | return mArraySize; |
| 193 | } |
| 194 | TLayoutBlockStorage blockStorage() const |
| 195 | { |
| 196 | return mBlockStorage; |
| 197 | } |
| 198 | TLayoutMatrixPacking matrixPacking() const |
| 199 | { |
| 200 | return mMatrixPacking; |
| 201 | } |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 202 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 203 | private: |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 204 | DISALLOW_COPY_AND_ASSIGN(TInterfaceBlock); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 205 | virtual TString mangledNamePrefix() const |
| 206 | { |
| 207 | return "iblock-"; |
| 208 | } |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 209 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 210 | const TString *mInstanceName; // for interface block instance names |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 211 | int mArraySize; // 0 if not an array |
| 212 | TLayoutBlockStorage mBlockStorage; |
| 213 | TLayoutMatrixPacking mMatrixPacking; |
| 214 | }; |
| 215 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 216 | // |
| 217 | // Base class for things that have a type. |
| 218 | // |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 219 | class TType |
| 220 | { |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 221 | public: |
Alok Priyadarshi | 8156b6b | 2013-09-23 14:56:58 -0400 | [diff] [blame] | 222 | POOL_ALLOCATOR_NEW_DELETE(); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 223 | TType() |
Nicolas Capens | c950884 | 2014-02-14 17:48:50 -0500 | [diff] [blame] | 224 | { |
| 225 | } |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 226 | TType(TBasicType t, unsigned char ps = 1, unsigned char ss = 1) |
| 227 | : type(t), precision(EbpUndefined), qualifier(EvqGlobal), |
| 228 | layoutQualifier(TLayoutQualifier::create()), |
| 229 | primarySize(ps), secondarySize(ss), array(false), arraySize(0), |
| 230 | interfaceBlock(0), structure(0) |
| 231 | { |
| 232 | } |
| 233 | TType(TBasicType t, TPrecision p, TQualifier q = EvqTemporary, |
| 234 | unsigned char ps = 1, unsigned char ss = 1, bool a = false) |
| 235 | : type(t), precision(p), qualifier(q), |
| 236 | layoutQualifier(TLayoutQualifier::create()), |
| 237 | primarySize(ps), secondarySize(ss), array(a), arraySize(0), |
| 238 | interfaceBlock(0), structure(0) |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 239 | { |
| 240 | } |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 241 | explicit TType(const TPublicType &p); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 242 | TType(TStructure *userDef, TPrecision p = EbpUndefined) |
| 243 | : type(EbtStruct), precision(p), qualifier(EvqTemporary), |
| 244 | layoutQualifier(TLayoutQualifier::create()), |
| 245 | primarySize(1), secondarySize(1), array(false), arraySize(0), |
| 246 | interfaceBlock(0), structure(userDef) |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 247 | { |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 248 | } |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 249 | TType(TInterfaceBlock *interfaceBlockIn, TQualifier qualifierIn, |
| 250 | TLayoutQualifier layoutQualifierIn, int arraySizeIn) |
| 251 | : type(EbtInterfaceBlock), precision(EbpUndefined), qualifier(qualifierIn), |
| 252 | layoutQualifier(layoutQualifierIn), |
| 253 | primarySize(1), secondarySize(1), array(arraySizeIn > 0), arraySize(arraySizeIn), |
| 254 | interfaceBlock(interfaceBlockIn), structure(0) |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 255 | { |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 256 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 257 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 258 | TBasicType getBasicType() const |
| 259 | { |
| 260 | return type; |
| 261 | } |
| 262 | void setBasicType(TBasicType t) |
| 263 | { |
| 264 | type = t; |
| 265 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 266 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 267 | TPrecision getPrecision() const |
| 268 | { |
| 269 | return precision; |
| 270 | } |
| 271 | void setPrecision(TPrecision p) |
| 272 | { |
| 273 | precision = p; |
| 274 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 275 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 276 | TQualifier getQualifier() const |
| 277 | { |
| 278 | return qualifier; |
| 279 | } |
| 280 | void setQualifier(TQualifier q) |
| 281 | { |
| 282 | qualifier = q; |
| 283 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 284 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 285 | TLayoutQualifier getLayoutQualifier() const |
| 286 | { |
| 287 | return layoutQualifier; |
| 288 | } |
| 289 | void setLayoutQualifier(TLayoutQualifier lq) |
| 290 | { |
| 291 | layoutQualifier = lq; |
| 292 | } |
Jamie Madill | a5efff9 | 2013-06-06 11:56:47 -0400 | [diff] [blame] | 293 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 294 | int getNominalSize() const |
| 295 | { |
| 296 | return primarySize; |
| 297 | } |
| 298 | int getSecondarySize() const |
| 299 | { |
| 300 | return secondarySize; |
| 301 | } |
| 302 | int getCols() const |
| 303 | { |
| 304 | ASSERT(isMatrix()); |
| 305 | return primarySize; |
| 306 | } |
| 307 | int getRows() const |
| 308 | { |
| 309 | ASSERT(isMatrix()); |
| 310 | return secondarySize; |
| 311 | } |
| 312 | void setPrimarySize(unsigned char ps) |
| 313 | { |
| 314 | primarySize = ps; |
| 315 | } |
| 316 | void setSecondarySize(unsigned char ss) |
| 317 | { |
| 318 | secondarySize = ss; |
| 319 | } |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 320 | |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 321 | // Full size of single instance of type |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 322 | size_t getObjectSize() const; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 323 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 324 | bool isMatrix() const |
| 325 | { |
| 326 | return primarySize > 1 && secondarySize > 1; |
| 327 | } |
| 328 | bool isArray() const |
| 329 | { |
| 330 | return array ? true : false; |
| 331 | } |
| 332 | int getArraySize() const |
| 333 | { |
| 334 | return arraySize; |
| 335 | } |
| 336 | void setArraySize(int s) |
| 337 | { |
| 338 | array = true; |
| 339 | arraySize = s; |
| 340 | } |
| 341 | void clearArrayness() |
| 342 | { |
| 343 | array = false; |
| 344 | arraySize = 0; |
| 345 | } |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 346 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 347 | TInterfaceBlock *getInterfaceBlock() const |
| 348 | { |
| 349 | return interfaceBlock; |
| 350 | } |
| 351 | void setInterfaceBlock(TInterfaceBlock *interfaceBlockIn) |
| 352 | { |
| 353 | interfaceBlock = interfaceBlockIn; |
| 354 | } |
| 355 | bool isInterfaceBlock() const |
| 356 | { |
| 357 | return type == EbtInterfaceBlock; |
| 358 | } |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 359 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 360 | bool isVector() const |
| 361 | { |
| 362 | return primarySize > 1 && secondarySize == 1; |
| 363 | } |
| 364 | bool isScalar() const |
| 365 | { |
| 366 | return primarySize == 1 && secondarySize == 1 && !structure; |
| 367 | } |
| 368 | bool isScalarInt() const |
| 369 | { |
| 370 | return isScalar() && (type == EbtInt || type == EbtUInt); |
| 371 | } |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 372 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 373 | TStructure *getStruct() const |
| 374 | { |
| 375 | return structure; |
| 376 | } |
| 377 | void setStruct(TStructure *s) |
| 378 | { |
| 379 | structure = s; |
| 380 | } |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 381 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 382 | const TString &getMangledName() |
| 383 | { |
| 384 | if (mangled.empty()) |
| 385 | { |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 386 | mangled = buildMangledName(); |
| 387 | mangled += ';'; |
daniel@transgaming.com | 0578f81 | 2010-05-17 09:58:39 +0000 | [diff] [blame] | 388 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 389 | |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 390 | return mangled; |
shannonwoods@chromium.org | 5668c5d | 2013-05-30 00:11:48 +0000 | [diff] [blame] | 391 | } |
| 392 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 393 | bool sameElementType(const TType &right) const |
| 394 | { |
| 395 | return type == right.type && |
| 396 | primarySize == right.primarySize && |
| 397 | secondarySize == right.secondarySize && |
| 398 | structure == right.structure; |
daniel@transgaming.com | 0578f81 | 2010-05-17 09:58:39 +0000 | [diff] [blame] | 399 | } |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 400 | bool operator==(const TType &right) const |
| 401 | { |
| 402 | return type == right.type && |
| 403 | primarySize == right.primarySize && |
| 404 | secondarySize == right.secondarySize && |
| 405 | array == right.array && (!array || arraySize == right.arraySize) && |
| 406 | structure == right.structure; |
daniel@transgaming.com | 0578f81 | 2010-05-17 09:58:39 +0000 | [diff] [blame] | 407 | // don't check the qualifier, it's not ever what's being sought after |
| 408 | } |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 409 | bool operator!=(const TType &right) const |
| 410 | { |
daniel@transgaming.com | 0578f81 | 2010-05-17 09:58:39 +0000 | [diff] [blame] | 411 | return !operator==(right); |
| 412 | } |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 413 | bool operator<(const TType &right) const |
| 414 | { |
| 415 | if (type != right.type) |
| 416 | return type < right.type; |
| 417 | if (primarySize != right.primarySize) |
| 418 | return primarySize < right.primarySize; |
| 419 | if (secondarySize != right.secondarySize) |
| 420 | return secondarySize < right.secondarySize; |
| 421 | if (array != right.array) |
| 422 | return array < right.array; |
| 423 | if (arraySize != right.arraySize) |
| 424 | return arraySize < right.arraySize; |
| 425 | if (structure != right.structure) |
| 426 | return structure < right.structure; |
daniel@transgaming.com | c6977ce | 2010-05-14 17:30:42 +0000 | [diff] [blame] | 427 | |
| 428 | return false; |
daniel@transgaming.com | 0578f81 | 2010-05-17 09:58:39 +0000 | [diff] [blame] | 429 | } |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 430 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 431 | const char *getBasicString() const |
| 432 | { |
| 433 | return ::getBasicString(type); |
| 434 | } |
| 435 | const char *getPrecisionString() const |
| 436 | { |
| 437 | return ::getPrecisionString(precision); |
| 438 | } |
| 439 | const char *getQualifierString() const |
| 440 | { |
| 441 | return ::getQualifierString(qualifier); |
| 442 | } |
daniel@transgaming.com | 0578f81 | 2010-05-17 09:58:39 +0000 | [diff] [blame] | 443 | TString getCompleteString() const; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 444 | |
kbr@chromium.org | 476541f | 2011-10-27 21:14:51 +0000 | [diff] [blame] | 445 | // If this type is a struct, returns the deepest struct nesting of |
| 446 | // any field in the struct. For example: |
| 447 | // struct nesting1 { |
| 448 | // vec4 position; |
| 449 | // }; |
| 450 | // struct nesting2 { |
| 451 | // nesting1 field1; |
| 452 | // vec4 field2; |
| 453 | // }; |
| 454 | // For type "nesting2", this method would return 2 -- the number |
| 455 | // of structures through which indirection must occur to reach the |
| 456 | // deepest field (nesting2.field1.position). |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 457 | int getDeepestStructNesting() const |
| 458 | { |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 459 | return structure ? structure->deepestNesting() : 0; |
| 460 | } |
kbr@chromium.org | 476541f | 2011-10-27 21:14:51 +0000 | [diff] [blame] | 461 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 462 | bool isStructureContainingArrays() const |
| 463 | { |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 464 | return structure ? structure->containsArrays() : false; |
| 465 | } |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 466 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 467 | protected: |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 468 | TString buildMangledName() const; |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 469 | size_t getStructSize() const; |
kbr@chromium.org | 476541f | 2011-10-27 21:14:51 +0000 | [diff] [blame] | 470 | void computeDeepestStructNesting(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 471 | |
Nicolas Capens | ef2c2b8 | 2013-09-26 10:06:07 -0400 | [diff] [blame] | 472 | TBasicType type; |
| 473 | TPrecision precision; |
| 474 | TQualifier qualifier; |
Jamie Madill | a5efff9 | 2013-06-06 11:56:47 -0400 | [diff] [blame] | 475 | TLayoutQualifier layoutQualifier; |
Nicolas Capens | ef2c2b8 | 2013-09-26 10:06:07 -0400 | [diff] [blame] | 476 | unsigned char primarySize; // size of vector or cols matrix |
| 477 | unsigned char secondarySize; // rows of a matrix |
| 478 | bool array; |
daniel@transgaming.com | 0578f81 | 2010-05-17 09:58:39 +0000 | [diff] [blame] | 479 | int arraySize; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 480 | |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 481 | // 0 unless this is an interface block, or interface block member variable |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 482 | TInterfaceBlock *interfaceBlock; |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 483 | |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 484 | // 0 unless this is a struct |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 485 | TStructure *structure; |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 486 | |
| 487 | mutable TString mangled; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 488 | }; |
| 489 | |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 490 | // |
| 491 | // This is a workaround for a problem with the yacc stack, It can't have |
| 492 | // types that it thinks have non-trivial constructors. It should |
| 493 | // just be used while recognizing the grammar, not anything else. Pointers |
| 494 | // could be used, but also trying to avoid lots of memory management overhead. |
| 495 | // |
| 496 | // Not as bad as it looks, there is no actual assumption that the fields |
| 497 | // match up or are name the same or anything like that. |
| 498 | // |
| 499 | struct TPublicType |
| 500 | { |
| 501 | TBasicType type; |
Jamie Madill | a5efff9 | 2013-06-06 11:56:47 -0400 | [diff] [blame] | 502 | TLayoutQualifier layoutQualifier; |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 503 | TQualifier qualifier; |
| 504 | TPrecision precision; |
Nicolas Capens | ef2c2b8 | 2013-09-26 10:06:07 -0400 | [diff] [blame] | 505 | unsigned char primarySize; // size of vector or cols of matrix |
| 506 | unsigned char secondarySize; // rows of matrix |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 507 | bool array; |
| 508 | int arraySize; |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 509 | TType *userDef; |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 510 | TSourceLoc line; |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 511 | |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 512 | void setBasic(TBasicType bt, TQualifier q, const TSourceLoc &ln) |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 513 | { |
| 514 | type = bt; |
Jamie Madill | a5efff9 | 2013-06-06 11:56:47 -0400 | [diff] [blame] | 515 | layoutQualifier = TLayoutQualifier::create(); |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 516 | qualifier = q; |
| 517 | precision = EbpUndefined; |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 518 | primarySize = 1; |
| 519 | secondarySize = 1; |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 520 | array = false; |
| 521 | arraySize = 0; |
| 522 | userDef = 0; |
| 523 | line = ln; |
| 524 | } |
| 525 | |
Nicolas Capens | ef2c2b8 | 2013-09-26 10:06:07 -0400 | [diff] [blame] | 526 | void setAggregate(unsigned char size) |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 527 | { |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 528 | primarySize = size; |
| 529 | } |
| 530 | |
Nicolas Capens | ef2c2b8 | 2013-09-26 10:06:07 -0400 | [diff] [blame] | 531 | void setMatrix(unsigned char c, unsigned char r) |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 532 | { |
| 533 | ASSERT(c > 1 && r > 1 && c <= 4 && r <= 4); |
| 534 | primarySize = c; |
| 535 | secondarySize = r; |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 536 | } |
| 537 | |
| 538 | void setArray(bool a, int s = 0) |
| 539 | { |
| 540 | array = a; |
| 541 | arraySize = s; |
| 542 | } |
| 543 | |
| 544 | bool isStructureContainingArrays() const |
| 545 | { |
| 546 | if (!userDef) |
| 547 | { |
| 548 | return false; |
| 549 | } |
| 550 | |
| 551 | return userDef->isStructureContainingArrays(); |
| 552 | } |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 553 | |
| 554 | bool isMatrix() const |
| 555 | { |
| 556 | return primarySize > 1 && secondarySize > 1; |
| 557 | } |
| 558 | |
| 559 | bool isVector() const |
| 560 | { |
| 561 | return primarySize > 1 && secondarySize == 1; |
| 562 | } |
| 563 | |
Shannon Woods | 3841b8e | 2013-09-10 18:23:12 -0400 | [diff] [blame] | 564 | int getCols() const |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 565 | { |
| 566 | ASSERT(isMatrix()); |
| 567 | return primarySize; |
| 568 | } |
| 569 | |
Shannon Woods | 3841b8e | 2013-09-10 18:23:12 -0400 | [diff] [blame] | 570 | int getRows() const |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 571 | { |
| 572 | ASSERT(isMatrix()); |
| 573 | return secondarySize; |
| 574 | } |
| 575 | |
Shannon Woods | 3841b8e | 2013-09-10 18:23:12 -0400 | [diff] [blame] | 576 | int getNominalSize() const |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 577 | { |
| 578 | return primarySize; |
| 579 | } |
| 580 | |
| 581 | bool isAggregate() const |
| 582 | { |
| 583 | return array || isMatrix() || isVector(); |
| 584 | } |
daniel@transgaming.com | 8abd0b7 | 2012-09-27 17:46:07 +0000 | [diff] [blame] | 585 | }; |
| 586 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 587 | #endif // _TYPES_INCLUDED_ |