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 | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 231 | class TSymbolTable |
| 232 | { |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 233 | public: |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 234 | TSymbolTable() |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 235 | { |
| 236 | // |
| 237 | // The symbol table cannot be used until push() is called, but |
| 238 | // the lack of an initial call to push() can be used to detect |
| 239 | // that the symbol table has not been preloaded with built-ins. |
| 240 | // |
| 241 | } |
| 242 | |
| 243 | ~TSymbolTable() |
| 244 | { |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 245 | while(currentLevel() > LAST_BUILTIN_LEVEL) |
| 246 | { |
| 247 | pop(); |
| 248 | } |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 249 | } |
| 250 | |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 251 | bool isEmpty() { return table.empty(); } |
| 252 | bool atBuiltInLevel() { return currentLevel() <= LAST_BUILTIN_LEVEL; } |
| 253 | bool atGlobalLevel() { return currentLevel() <= GLOBAL_LEVEL; } |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 254 | void push() |
| 255 | { |
| 256 | table.push_back(new TSymbolTableLevel); |
| 257 | precisionStack.push_back( PrecisionStackLevel() ); |
| 258 | } |
| 259 | |
| 260 | void pop() |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 261 | { |
| 262 | delete table[currentLevel()]; |
| 263 | table.pop_back(); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 264 | precisionStack.pop_back(); |
| 265 | } |
| 266 | |
Nicolas Capens | d603ecd | 2015-02-18 14:52:21 -0500 | [diff] [blame] | 267 | bool declare(TSymbol &symbol) |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 268 | { |
Nicolas Capens | d603ecd | 2015-02-18 14:52:21 -0500 | [diff] [blame] | 269 | return insert(currentLevel(), symbol); |
| 270 | } |
| 271 | |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 272 | bool insert(ESymbolLevel level, TSymbol &symbol) |
Nicolas Capens | d603ecd | 2015-02-18 14:52:21 -0500 | [diff] [blame] | 273 | { |
| 274 | return table[level]->insert(symbol); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 275 | } |
| 276 | |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 277 | bool insertConstInt(ESymbolLevel level, const char *name, int value) |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 278 | { |
| 279 | TVariable *constant = new TVariable(NewPoolTString(name), TType(EbtInt, EbpUndefined, EvqConst, 1)); |
| 280 | constant->getConstPointer()->setIConst(value); |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 281 | return insert(level, *constant); |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 282 | } |
| 283 | |
Nicolas Capens | f8a4cba | 2015-02-18 17:30:46 -0500 | [diff] [blame] | 284 | 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] | 285 | { |
Nicolas Capens | f8a4cba | 2015-02-18 17:30:46 -0500 | [diff] [blame] | 286 | if(ptype1->getBasicType() == EbtGSampler2D) |
| 287 | { |
| 288 | bool gvec4 = (rvalue->getBasicType() == EbtGVec4); |
| 289 | insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler2D), ptype2, ptype3, ptype4); |
| 290 | insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler2D), ptype2, ptype3, ptype4); |
| 291 | insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler2D), ptype2, ptype3, ptype4); |
| 292 | return; |
| 293 | } |
| 294 | else if(ptype1->getBasicType() == EbtGSampler3D) |
| 295 | { |
| 296 | bool gvec4 = (rvalue->getBasicType() == EbtGVec4); |
| 297 | insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler3D), ptype2, ptype3, ptype4); |
| 298 | insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler3D), ptype2, ptype3, ptype4); |
| 299 | insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler3D), ptype2, ptype3, ptype4); |
| 300 | return; |
| 301 | } |
| 302 | else if(ptype1->getBasicType() == EbtGSamplerCube) |
| 303 | { |
| 304 | bool gvec4 = (rvalue->getBasicType() == EbtGVec4); |
| 305 | insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSamplerCube), ptype2, ptype3, ptype4); |
| 306 | insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISamplerCube), ptype2, ptype3, ptype4); |
| 307 | insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSamplerCube), ptype2, ptype3, ptype4); |
| 308 | return; |
| 309 | } |
| 310 | else if(ptype1->getBasicType() == EbtGSampler2DArray) |
| 311 | { |
| 312 | bool gvec4 = (rvalue->getBasicType() == EbtGVec4); |
| 313 | insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler2DArray), ptype2, ptype3, ptype4); |
| 314 | insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler2DArray), ptype2, ptype3, ptype4); |
| 315 | insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler2DArray), ptype2, ptype3, ptype4); |
| 316 | return; |
| 317 | } |
| 318 | |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 319 | TFunction *function = new TFunction(NewPoolTString(name), *rvalue); |
| 320 | |
Nicolas Capens | 434311c | 2014-05-28 19:23:55 -0400 | [diff] [blame] | 321 | TParameter param1 = {0, ptype1}; |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 322 | function->addParameter(param1); |
| 323 | |
Nicolas Capens | 434311c | 2014-05-28 19:23:55 -0400 | [diff] [blame] | 324 | if(ptype2) |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 325 | { |
Nicolas Capens | 434311c | 2014-05-28 19:23:55 -0400 | [diff] [blame] | 326 | TParameter param2 = {0, ptype2}; |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 327 | function->addParameter(param2); |
| 328 | } |
| 329 | |
Nicolas Capens | 434311c | 2014-05-28 19:23:55 -0400 | [diff] [blame] | 330 | if(ptype3) |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 331 | { |
Nicolas Capens | 434311c | 2014-05-28 19:23:55 -0400 | [diff] [blame] | 332 | TParameter param3 = {0, ptype3}; |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 333 | function->addParameter(param3); |
| 334 | } |
| 335 | |
Nicolas Capens | f8a4cba | 2015-02-18 17:30:46 -0500 | [diff] [blame] | 336 | insert(level, *function); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 337 | } |
| 338 | |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 339 | TSymbol *find(const TString &name, int shaderVersion, bool *builtIn = false, bool *sameScope = false) const; |
| 340 | TSymbol *findBuiltIn(const TString &name, int shaderVersion) const; |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 341 | |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 342 | TSymbolTableLevel *getOuterLevel() const |
| 343 | { |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 344 | assert(currentLevel() >= 1); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 345 | return table[currentLevel() - 1]; |
| 346 | } |
| 347 | |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 348 | void relateToOperator(ESymbolLevel level, const char *name, TOperator op) |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 349 | { |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 350 | table[level]->relateToOperator(name, op); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 351 | } |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 352 | |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 353 | void relateToExtension(ESymbolLevel level, const char *name, const TString &ext) |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 354 | { |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 355 | table[level]->relateToExtension(name, ext); |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 356 | } |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 357 | |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 358 | bool setDefaultPrecision(const TPublicType &type, TPrecision prec) |
| 359 | { |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 360 | if (IsSampler(type.type)) |
| 361 | return true; // Skip sampler types for the time being |
| 362 | if (type.type != EbtFloat && type.type != EbtInt) |
| 363 | return false; // Only set default precision for int/float |
| 364 | if (type.size != 1 || type.matrix || type.array) |
| 365 | return false; // Not allowed to set for aggregate types |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 366 | int indexOfLastElement = static_cast<int>(precisionStack.size()) - 1; |
John Bauman | d4ae863 | 2014-05-06 16:18:33 -0400 | [diff] [blame] | 367 | precisionStack[indexOfLastElement][type.type] = prec; // Uses map operator [], overwrites the current value |
| 368 | return true; |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 369 | } |
| 370 | |
| 371 | // Searches down the precisionStack for a precision qualifier for the specified TBasicType |
Nicolas Capens | 3c20f80 | 2015-02-17 17:17:20 -0500 | [diff] [blame] | 372 | TPrecision getDefaultPrecision( TBasicType type) |
| 373 | { |
| 374 | // unsigned integers use the same precision as signed |
| 375 | if (type == EbtUInt) type = EbtInt; |
| 376 | |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 377 | if( type != EbtFloat && type != EbtInt ) return EbpUndefined; |
| 378 | int level = static_cast<int>(precisionStack.size()) - 1; |
| 379 | assert( level >= 0); // Just to be safe. Should not happen. |
| 380 | PrecisionStackLevel::iterator it; |
| 381 | TPrecision prec = EbpUndefined; // If we dont find anything we return this. Should we error check this? |
| 382 | while( level >= 0 ){ |
| 383 | it = precisionStack[level].find( type ); |
| 384 | if( it != precisionStack[level].end() ){ |
| 385 | prec = (*it).second; |
| 386 | break; |
| 387 | } |
| 388 | level--; |
| 389 | } |
| 390 | return prec; |
| 391 | } |
| 392 | |
Nicolas Capens | 0a7f0c2 | 2015-02-18 14:47:31 -0500 | [diff] [blame] | 393 | protected: |
Nicolas Capens | e285865 | 2015-02-18 15:30:51 -0500 | [diff] [blame] | 394 | ESymbolLevel currentLevel() const { return static_cast<ESymbolLevel>(table.size() - 1); } |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 395 | |
| 396 | std::vector<TSymbolTableLevel*> table; |
| 397 | typedef std::map< TBasicType, TPrecision > PrecisionStackLevel; |
| 398 | std::vector< PrecisionStackLevel > precisionStack; |
John Bauman | 66b8ab2 | 2014-05-06 15:57:45 -0400 | [diff] [blame] | 399 | }; |
| 400 | |
| 401 | #endif // _SYMBOL_TABLE_INCLUDED_ |