John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 1 | // |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 2 | // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved. |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [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 _SYMBOL_TABLE_INCLUDED_ |
| 8 | #define _SYMBOL_TABLE_INCLUDED_ |
| 9 | |
| 10 | // |
| 11 | // Symbol table for parsing. Has these design characteristics: |
| 12 | // |
| 13 | // * Same symbol table can be used to compile many shaders, to preserve |
| 14 | // effort of creating and loading with the large numbers of built-in |
| 15 | // symbols. |
| 16 | // |
| 17 | // * Name mangling will be used to give each function a unique name |
| 18 | // so that symbol table lookups are never ambiguous. This allows |
| 19 | // a simpler symbol table structure. |
| 20 | // |
| 21 | // * Pushing and popping of scope, so symbol table will really be a stack |
| 22 | // of symbol tables. Searched from the top, with new inserts going into |
| 23 | // the top. |
| 24 | // |
| 25 | // * Constants: Compile time constant symbols will keep their values |
| 26 | // in the symbol table. The parser can substitute constants at parse |
| 27 | // time, including doing constant folding and constant propagation. |
| 28 | // |
| 29 | // * No temporaries: Temporaries made from operations (+, --, .xy, etc.) |
| 30 | // are tracked in the intermediate representation, not the symbol table. |
| 31 | // |
| 32 | |
| 33 | #include <assert.h> |
| 34 | |
Nicolas Capens | cc863da | 2015-01-21 15:50:55 -0500 | [diff] [blame] | 35 | #include "InfoSink.h" |
| 36 | #include "intermediate.h" |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 37 | |
| 38 | // |
| 39 | // Symbol base class. (Can build functions or variables out of these...) |
| 40 | // |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 41 | class TSymbol |
| 42 | { |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 43 | public: |
Nicolas Capens | 978ddc5 | 2014-11-11 12:42:08 -0500 | [diff] [blame] | 44 | POOL_ALLOCATOR_NEW_DELETE(); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 45 | TSymbol(const TString *n) : name(n) { } |
| 46 | virtual ~TSymbol() { /* don't delete name, it's from the pool */ } |
Nicolas Capens | 978ddc5 | 2014-11-11 12:42:08 -0500 | [diff] [blame] | 47 | |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 48 | const TString& getName() const { return *name; } |
| 49 | virtual const TString& getMangledName() const { return getName(); } |
| 50 | virtual bool isFunction() const { return false; } |
| 51 | virtual bool isVariable() const { return false; } |
| 52 | void setUniqueId(int id) { uniqueId = id; } |
| 53 | int getUniqueId() const { return uniqueId; } |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 54 | TSymbol(const TSymbol&); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 55 | |
| 56 | protected: |
| 57 | const TString *name; |
| 58 | unsigned int uniqueId; // For real comparing during code generation |
| 59 | }; |
| 60 | |
| 61 | // |
| 62 | // Variable class, meaning a symbol that's not a function. |
| 63 | // |
| 64 | // There could be a separate class heirarchy for Constant variables; |
| 65 | // Only one of int, bool, or float, (or none) is correct for |
| 66 | // any particular use, but it's easy to do this way, and doesn't |
| 67 | // seem worth having separate classes, and "getConst" can't simply return |
| 68 | // different values for different types polymorphically, so this is |
| 69 | // just simple and pragmatic. |
| 70 | // |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 71 | class TVariable : public TSymbol |
| 72 | { |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 73 | public: |
| 74 | TVariable(const TString *name, const TType& t, bool uT = false ) : TSymbol(name), type(t), userType(uT), unionArray(0), arrayInformationType(0) { } |
| 75 | virtual ~TVariable() { } |
| 76 | virtual bool isVariable() const { return true; } |
| 77 | TType& getType() { return type; } |
| 78 | const TType& getType() const { return type; } |
| 79 | bool isUserType() const { return userType; } |
| 80 | void setQualifier(TQualifier qualifier) { type.setQualifier(qualifier); } |
| 81 | void updateArrayInformationType(TType *t) { arrayInformationType = t; } |
| 82 | TType* getArrayInformationType() { return arrayInformationType; } |
| 83 | |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 84 | ConstantUnion* getConstPointer() |
| 85 | { |
| 86 | if (!unionArray) |
| 87 | unionArray = new ConstantUnion[type.getObjectSize()]; |
| 88 | |
| 89 | return unionArray; |
| 90 | } |
| 91 | |
| 92 | ConstantUnion* getConstPointer() const { return unionArray; } |
| 93 | |
| 94 | void shareConstPointer( ConstantUnion *constArray) |
| 95 | { |
| 96 | if (unionArray == constArray) |
| 97 | return; |
| 98 | |
| 99 | delete[] unionArray; |
| 100 | unionArray = constArray; |
| 101 | } |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 102 | |
| 103 | protected: |
| 104 | TType type; |
| 105 | bool userType; |
| 106 | // we are assuming that Pool Allocator will free the memory allocated to unionArray |
| 107 | // when this object is destroyed |
| 108 | ConstantUnion *unionArray; |
| 109 | TType *arrayInformationType; // this is used for updating maxArraySize in all the references to a given symbol |
| 110 | }; |
| 111 | |
| 112 | // |
| 113 | // The function sub-class of symbols and the parser will need to |
| 114 | // share this definition of a function parameter. |
| 115 | // |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 116 | struct TParameter |
| 117 | { |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 118 | TString *name; |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 119 | TType *type; |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 120 | }; |
| 121 | |
| 122 | // |
| 123 | // The function sub-class of a symbol. |
| 124 | // |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 125 | class TFunction : public TSymbol |
| 126 | { |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 127 | public: |
| 128 | TFunction(TOperator o) : |
| 129 | TSymbol(0), |
| 130 | returnType(TType(EbtVoid, EbpUndefined)), |
| 131 | op(o), |
| 132 | defined(false) { } |
| 133 | TFunction(const TString *name, TType& retType, TOperator tOp = EOpNull) : |
| 134 | TSymbol(name), |
| 135 | returnType(retType), |
| 136 | mangledName(TFunction::mangleName(*name)), |
| 137 | op(tOp), |
| 138 | defined(false) { } |
| 139 | virtual ~TFunction(); |
| 140 | virtual bool isFunction() const { return true; } |
| 141 | |
| 142 | static TString mangleName(const TString& name) { return name + '('; } |
| 143 | static TString unmangleName(const TString& mangledName) |
| 144 | { |
| 145 | return TString(mangledName.c_str(), mangledName.find_first_of('(')); |
| 146 | } |
| 147 | |
| 148 | void addParameter(TParameter& p) |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 149 | { |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 150 | parameters.push_back(p); |
| 151 | mangledName = mangledName + p.type->getMangledName(); |
| 152 | } |
| 153 | |
| 154 | const TString& getMangledName() const { return mangledName; } |
| 155 | const TType& getReturnType() const { return returnType; } |
| 156 | |
| 157 | void relateToOperator(TOperator o) { op = o; } |
| 158 | TOperator getBuiltInOp() const { return op; } |
| 159 | |
| 160 | void relateToExtension(const TString& ext) { extension = ext; } |
| 161 | const TString& getExtension() const { return extension; } |
| 162 | |
| 163 | void setDefined() { defined = true; } |
| 164 | bool isDefined() { return defined; } |
| 165 | |
| 166 | int getParamCount() const { return static_cast<int>(parameters.size()); } |
| 167 | const TParameter& getParam(int i) const { return parameters[i]; } |
| 168 | |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 169 | protected: |
| 170 | typedef TVector<TParameter> TParamList; |
| 171 | TParamList parameters; |
| 172 | TType returnType; |
| 173 | TString mangledName; |
| 174 | TOperator op; |
| 175 | TString extension; |
| 176 | bool defined; |
| 177 | }; |
| 178 | |
| 179 | |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 180 | class TSymbolTableLevel |
| 181 | { |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 182 | public: |
| 183 | typedef TMap<TString, TSymbol*> tLevel; |
| 184 | typedef tLevel::const_iterator const_iterator; |
| 185 | typedef const tLevel::value_type tLevelPair; |
| 186 | typedef std::pair<tLevel::iterator, bool> tInsertResult; |
| 187 | |
Nicolas Capens | 978ddc5 | 2014-11-11 12:42:08 -0500 | [diff] [blame] | 188 | POOL_ALLOCATOR_NEW_DELETE(); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 189 | TSymbolTableLevel() { } |
| 190 | ~TSymbolTableLevel(); |
| 191 | |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 192 | bool insert(TSymbol &symbol) |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 193 | { |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 194 | symbol.setUniqueId(++uniqueId); |
| 195 | |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 196 | // |
| 197 | // returning true means symbol was added to the table |
| 198 | // |
| 199 | tInsertResult result; |
| 200 | result = level.insert(tLevelPair(symbol.getMangledName(), &symbol)); |
| 201 | |
| 202 | return result.second; |
| 203 | } |
| 204 | |
| 205 | TSymbol* find(const TString& name) const |
| 206 | { |
| 207 | tLevel::const_iterator it = level.find(name); |
| 208 | if (it == level.end()) |
| 209 | return 0; |
| 210 | else |
| 211 | return (*it).second; |
| 212 | } |
| 213 | |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 214 | void relateToOperator(const char* name, TOperator op); |
| 215 | void relateToExtension(const char* name, const TString& ext); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 216 | |
| 217 | protected: |
| 218 | tLevel level; |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 219 | static int uniqueId; // for unique identification in code generation |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 220 | }; |
| 221 | |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 222 | enum ESymbolLevel |
| 223 | { |
Nicolas Capens | 3d7f6ed | 2015-02-18 16:34:50 -0500 | [diff] [blame] | 224 | COMMON_BUILTINS, |
| 225 | ESSL1_BUILTINS, |
| 226 | ESSL3_BUILTINS, |
| 227 | LAST_BUILTIN_LEVEL = ESSL3_BUILTINS, |
| 228 | GLOBAL_LEVEL |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 229 | }; |
| 230 | |
Nicolas Capens | 8fa9d23 | 2015-02-19 15:53:16 -0500 | [diff] [blame^] | 231 | inline bool IsGenType(const TType *type) |
| 232 | { |
| 233 | if(type) |
| 234 | { |
| 235 | TBasicType basicType = type->getBasicType(); |
| 236 | return basicType == EbtGenType || basicType == EbtGenIType || basicType == EbtGenUType || basicType == EbtGenBType; |
| 237 | } |
| 238 | |
| 239 | return false; |
| 240 | } |
| 241 | |
| 242 | inline bool IsVecType(const TType *type) |
| 243 | { |
| 244 | if(type) |
| 245 | { |
| 246 | TBasicType basicType = type->getBasicType(); |
| 247 | return basicType == EbtVec || basicType == EbtIVec || basicType == EbtUVec || basicType == EbtBVec; |
| 248 | } |
| 249 | |
| 250 | return false; |
| 251 | } |
| 252 | |
| 253 | inline TType *GenType(TType *type, int size) |
| 254 | { |
| 255 | ASSERT(size >= 1 && size <= 4); |
| 256 | |
| 257 | if(!type) |
| 258 | { |
| 259 | return nullptr; |
| 260 | } |
| 261 | |
| 262 | ASSERT(!IsVecType(type)); |
| 263 | |
| 264 | switch(type->getBasicType()) |
| 265 | { |
| 266 | case EbtGenType: return new TType(EbtFloat, size); |
| 267 | case EbtGenIType: return new TType(EbtInt, size); |
| 268 | case EbtGenUType: return new TType(EbtUInt, size); |
| 269 | case EbtGenBType: return new TType(EbtBool, size); |
| 270 | default: return type; |
| 271 | } |
| 272 | } |
| 273 | |
| 274 | inline TType *VecType(TType *type, int size) |
| 275 | { |
| 276 | ASSERT(size >= 2 && size <= 4); |
| 277 | |
| 278 | if(!type) |
| 279 | { |
| 280 | return nullptr; |
| 281 | } |
| 282 | |
| 283 | ASSERT(!IsGenType(type)); |
| 284 | |
| 285 | switch(type->getBasicType()) |
| 286 | { |
| 287 | case EbtVec: return new TType(EbtFloat, size); |
| 288 | case EbtIVec: return new TType(EbtInt, size); |
| 289 | case EbtUVec: return new TType(EbtUInt, size); |
| 290 | case EbtBVec: return new TType(EbtBool, size); |
| 291 | default: return type; |
| 292 | } |
| 293 | } |
| 294 | |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 295 | class TSymbolTable |
| 296 | { |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 297 | public: |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 298 | TSymbolTable() |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 299 | { |
| 300 | // |
| 301 | // The symbol table cannot be used until push() is called, but |
| 302 | // the lack of an initial call to push() can be used to detect |
| 303 | // that the symbol table has not been preloaded with built-ins. |
| 304 | // |
| 305 | } |
| 306 | |
| 307 | ~TSymbolTable() |
| 308 | { |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 309 | while(currentLevel() > LAST_BUILTIN_LEVEL) |
| 310 | { |
| 311 | pop(); |
| 312 | } |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 313 | } |
| 314 | |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 315 | bool isEmpty() { return table.empty(); } |
| 316 | bool atBuiltInLevel() { return currentLevel() <= LAST_BUILTIN_LEVEL; } |
| 317 | bool atGlobalLevel() { return currentLevel() <= GLOBAL_LEVEL; } |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 318 | void push() |
| 319 | { |
| 320 | table.push_back(new TSymbolTableLevel); |
| 321 | precisionStack.push_back( PrecisionStackLevel() ); |
| 322 | } |
| 323 | |
| 324 | void pop() |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 325 | { |
| 326 | delete table[currentLevel()]; |
| 327 | table.pop_back(); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 328 | precisionStack.pop_back(); |
| 329 | } |
| 330 | |
Nicolas Capens | d603ecd | 2015-02-18 14:52:21 -0500 | [diff] [blame] | 331 | bool declare(TSymbol &symbol) |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 332 | { |
Nicolas Capens | d603ecd | 2015-02-18 14:52:21 -0500 | [diff] [blame] | 333 | return insert(currentLevel(), symbol); |
| 334 | } |
| 335 | |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 336 | bool insert(ESymbolLevel level, TSymbol &symbol) |
Nicolas Capens | d603ecd | 2015-02-18 14:52:21 -0500 | [diff] [blame] | 337 | { |
| 338 | return table[level]->insert(symbol); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 339 | } |
| 340 | |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 341 | bool insertConstInt(ESymbolLevel level, const char *name, int value) |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 342 | { |
| 343 | TVariable *constant = new TVariable(NewPoolTString(name), TType(EbtInt, EbpUndefined, EvqConst, 1)); |
| 344 | constant->getConstPointer()->setIConst(value); |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 345 | return insert(level, *constant); |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 346 | } |
| 347 | |
Nicolas Capens | f8a4cba | 2015-02-18 17:30:46 -0500 | [diff] [blame] | 348 | void insertBuiltIn(ESymbolLevel level, TType *rvalue, const char *name, TType *ptype1, TType *ptype2 = 0, TType *ptype3 = 0, TType *ptype4 = 0) |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 349 | { |
Nicolas Capens | f8a4cba | 2015-02-18 17:30:46 -0500 | [diff] [blame] | 350 | if(ptype1->getBasicType() == EbtGSampler2D) |
| 351 | { |
| 352 | bool gvec4 = (rvalue->getBasicType() == EbtGVec4); |
| 353 | insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler2D), ptype2, ptype3, ptype4); |
| 354 | insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler2D), ptype2, ptype3, ptype4); |
| 355 | insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler2D), ptype2, ptype3, ptype4); |
| 356 | return; |
| 357 | } |
| 358 | else if(ptype1->getBasicType() == EbtGSampler3D) |
| 359 | { |
| 360 | bool gvec4 = (rvalue->getBasicType() == EbtGVec4); |
| 361 | insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler3D), ptype2, ptype3, ptype4); |
| 362 | insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler3D), ptype2, ptype3, ptype4); |
| 363 | insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler3D), ptype2, ptype3, ptype4); |
| 364 | return; |
| 365 | } |
| 366 | else if(ptype1->getBasicType() == EbtGSamplerCube) |
| 367 | { |
| 368 | bool gvec4 = (rvalue->getBasicType() == EbtGVec4); |
| 369 | insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSamplerCube), ptype2, ptype3, ptype4); |
| 370 | insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISamplerCube), ptype2, ptype3, ptype4); |
| 371 | insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSamplerCube), ptype2, ptype3, ptype4); |
| 372 | return; |
| 373 | } |
| 374 | else if(ptype1->getBasicType() == EbtGSampler2DArray) |
| 375 | { |
| 376 | bool gvec4 = (rvalue->getBasicType() == EbtGVec4); |
| 377 | insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler2DArray), ptype2, ptype3, ptype4); |
| 378 | insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler2DArray), ptype2, ptype3, ptype4); |
| 379 | insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler2DArray), ptype2, ptype3, ptype4); |
| 380 | return; |
| 381 | } |
Nicolas Capens | 8fa9d23 | 2015-02-19 15:53:16 -0500 | [diff] [blame^] | 382 | else if(IsGenType(rvalue) || |
| 383 | IsGenType(ptype1) || |
| 384 | IsGenType(ptype2) || |
| 385 | IsGenType(ptype3) || |
| 386 | IsGenType(ptype4)) |
| 387 | { |
| 388 | insertBuiltIn(level, GenType(rvalue, 1), name, GenType(ptype1, 1), GenType(ptype2, 1), GenType(ptype3, 1), GenType(ptype4, 1)); |
| 389 | insertBuiltIn(level, GenType(rvalue, 2), name, GenType(ptype1, 2), GenType(ptype2, 2), GenType(ptype3, 2), GenType(ptype4, 2)); |
| 390 | insertBuiltIn(level, GenType(rvalue, 3), name, GenType(ptype1, 3), GenType(ptype2, 3), GenType(ptype3, 3), GenType(ptype4, 3)); |
| 391 | insertBuiltIn(level, GenType(rvalue, 4), name, GenType(ptype1, 4), GenType(ptype2, 4), GenType(ptype3, 4), GenType(ptype4, 4)); |
| 392 | return; |
| 393 | } |
| 394 | else if(IsVecType(rvalue) || |
| 395 | IsVecType(ptype1) || |
| 396 | IsVecType(ptype2) || |
| 397 | IsVecType(ptype3) || |
| 398 | IsVecType(ptype4)) |
| 399 | { |
| 400 | insertBuiltIn(level, VecType(rvalue, 2), name, VecType(ptype1, 2), VecType(ptype2, 2), VecType(ptype3, 2), VecType(ptype4, 2)); |
| 401 | insertBuiltIn(level, VecType(rvalue, 3), name, VecType(ptype1, 3), VecType(ptype2, 3), VecType(ptype3, 3), VecType(ptype4, 3)); |
| 402 | insertBuiltIn(level, VecType(rvalue, 4), name, VecType(ptype1, 4), VecType(ptype2, 4), VecType(ptype3, 4), VecType(ptype4, 4)); |
| 403 | return; |
| 404 | } |
Nicolas Capens | f8a4cba | 2015-02-18 17:30:46 -0500 | [diff] [blame] | 405 | |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 406 | TFunction *function = new TFunction(NewPoolTString(name), *rvalue); |
| 407 | |
Nicolas Capens | 434311c | 2014-05-28 19:23:55 -0400 | [diff] [blame] | 408 | TParameter param1 = {0, ptype1}; |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 409 | function->addParameter(param1); |
| 410 | |
Nicolas Capens | 434311c | 2014-05-28 19:23:55 -0400 | [diff] [blame] | 411 | if(ptype2) |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 412 | { |
Nicolas Capens | 434311c | 2014-05-28 19:23:55 -0400 | [diff] [blame] | 413 | TParameter param2 = {0, ptype2}; |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 414 | function->addParameter(param2); |
| 415 | } |
| 416 | |
Nicolas Capens | 434311c | 2014-05-28 19:23:55 -0400 | [diff] [blame] | 417 | if(ptype3) |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 418 | { |
Nicolas Capens | 434311c | 2014-05-28 19:23:55 -0400 | [diff] [blame] | 419 | TParameter param3 = {0, ptype3}; |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 420 | function->addParameter(param3); |
| 421 | } |
| 422 | |
Nicolas Capens | 8fa9d23 | 2015-02-19 15:53:16 -0500 | [diff] [blame^] | 423 | if(ptype4) |
| 424 | { |
| 425 | TParameter param4 = {0, ptype4}; |
| 426 | function->addParameter(param4); |
| 427 | } |
| 428 | |
Nicolas Capens | f8a4cba | 2015-02-18 17:30:46 -0500 | [diff] [blame] | 429 | insert(level, *function); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 430 | } |
| 431 | |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 432 | TSymbol *find(const TString &name, int shaderVersion, bool *builtIn = false, bool *sameScope = false) const; |
| 433 | TSymbol *findBuiltIn(const TString &name, int shaderVersion) const; |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 434 | |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 435 | TSymbolTableLevel *getOuterLevel() const |
| 436 | { |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 437 | assert(currentLevel() >= 1); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 438 | return table[currentLevel() - 1]; |
| 439 | } |
| 440 | |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 441 | void relateToOperator(ESymbolLevel level, const char *name, TOperator op) |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 442 | { |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 443 | table[level]->relateToOperator(name, op); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 444 | } |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 445 | |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 446 | void relateToExtension(ESymbolLevel level, const char *name, const TString &ext) |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 447 | { |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 448 | table[level]->relateToExtension(name, ext); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 449 | } |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 450 | |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 451 | bool setDefaultPrecision(const TPublicType &type, TPrecision prec) |
| 452 | { |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 453 | if (IsSampler(type.type)) |
| 454 | return true; // Skip sampler types for the time being |
| 455 | if (type.type != EbtFloat && type.type != EbtInt) |
| 456 | return false; // Only set default precision for int/float |
| 457 | if (type.size != 1 || type.matrix || type.array) |
| 458 | return false; // Not allowed to set for aggregate types |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 459 | int indexOfLastElement = static_cast<int>(precisionStack.size()) - 1; |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 460 | precisionStack[indexOfLastElement][type.type] = prec; // Uses map operator [], overwrites the current value |
| 461 | return true; |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 462 | } |
| 463 | |
| 464 | // Searches down the precisionStack for a precision qualifier for the specified TBasicType |
Nicolas Capens | 3c20f80 | 2015-02-17 17:17:20 -0500 | [diff] [blame] | 465 | TPrecision getDefaultPrecision( TBasicType type) |
| 466 | { |
| 467 | // unsigned integers use the same precision as signed |
| 468 | if (type == EbtUInt) type = EbtInt; |
| 469 | |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 470 | if( type != EbtFloat && type != EbtInt ) return EbpUndefined; |
| 471 | int level = static_cast<int>(precisionStack.size()) - 1; |
| 472 | assert( level >= 0); // Just to be safe. Should not happen. |
| 473 | PrecisionStackLevel::iterator it; |
| 474 | TPrecision prec = EbpUndefined; // If we dont find anything we return this. Should we error check this? |
| 475 | while( level >= 0 ){ |
| 476 | it = precisionStack[level].find( type ); |
| 477 | if( it != precisionStack[level].end() ){ |
| 478 | prec = (*it).second; |
| 479 | break; |
| 480 | } |
| 481 | level--; |
| 482 | } |
| 483 | return prec; |
| 484 | } |
| 485 | |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 486 | protected: |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 487 | ESymbolLevel currentLevel() const { return static_cast<ESymbolLevel>(table.size() - 1); } |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 488 | |
| 489 | std::vector<TSymbolTableLevel*> table; |
| 490 | typedef std::map< TBasicType, TPrecision > PrecisionStackLevel; |
| 491 | std::vector< PrecisionStackLevel > precisionStack; |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 492 | }; |
| 493 | |
| 494 | #endif // _SYMBOL_TABLE_INCLUDED_ |