blob: 9607fa8f95e5331329737ed6062024d5c0067d1c [file] [log] [blame]
John Bauman66b8ab22014-05-06 15:57:45 -04001//
John Baumand4ae8632014-05-06 16:18:33 -04002// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
John Bauman66b8ab22014-05-06 15:57:45 -04003// 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 Capenscc863da2015-01-21 15:50:55 -050035#include "InfoSink.h"
36#include "intermediate.h"
John Bauman66b8ab22014-05-06 15:57:45 -040037
38//
39// Symbol base class. (Can build functions or variables out of these...)
40//
Nicolas Capens0a7f0c22015-02-18 14:47:31 -050041class TSymbol
42{
John Bauman66b8ab22014-05-06 15:57:45 -040043public:
Nicolas Capens978ddc52014-11-11 12:42:08 -050044 POOL_ALLOCATOR_NEW_DELETE();
John Bauman66b8ab22014-05-06 15:57:45 -040045 TSymbol(const TString *n) : name(n) { }
46 virtual ~TSymbol() { /* don't delete name, it's from the pool */ }
Nicolas Capens978ddc52014-11-11 12:42:08 -050047
John Bauman66b8ab22014-05-06 15:57:45 -040048 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 Bauman66b8ab22014-05-06 15:57:45 -040054 TSymbol(const TSymbol&);
John Bauman66b8ab22014-05-06 15:57:45 -040055
56protected:
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 Capens0a7f0c22015-02-18 14:47:31 -050071class TVariable : public TSymbol
72{
John Bauman66b8ab22014-05-06 15:57:45 -040073public:
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 Bauman66b8ab22014-05-06 15:57:45 -040084 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 Bauman66b8ab22014-05-06 15:57:45 -0400102
103protected:
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 Capens0a7f0c22015-02-18 14:47:31 -0500116struct TParameter
117{
John Bauman66b8ab22014-05-06 15:57:45 -0400118 TString *name;
John Baumand4ae8632014-05-06 16:18:33 -0400119 TType *type;
John Bauman66b8ab22014-05-06 15:57:45 -0400120};
121
122//
123// The function sub-class of a symbol.
124//
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500125class TFunction : public TSymbol
126{
John Bauman66b8ab22014-05-06 15:57:45 -0400127public:
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 Capens0a7f0c22015-02-18 14:47:31 -0500149 {
John Bauman66b8ab22014-05-06 15:57:45 -0400150 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 Bauman66b8ab22014-05-06 15:57:45 -0400169protected:
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 Capens0a7f0c22015-02-18 14:47:31 -0500180class TSymbolTableLevel
181{
John Bauman66b8ab22014-05-06 15:57:45 -0400182public:
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 Capens978ddc52014-11-11 12:42:08 -0500188 POOL_ALLOCATOR_NEW_DELETE();
John Bauman66b8ab22014-05-06 15:57:45 -0400189 TSymbolTableLevel() { }
190 ~TSymbolTableLevel();
191
John Baumand4ae8632014-05-06 16:18:33 -0400192 bool insert(TSymbol &symbol)
John Bauman66b8ab22014-05-06 15:57:45 -0400193 {
John Baumand4ae8632014-05-06 16:18:33 -0400194 symbol.setUniqueId(++uniqueId);
195
John Bauman66b8ab22014-05-06 15:57:45 -0400196 //
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 Bauman66b8ab22014-05-06 15:57:45 -0400214 void relateToOperator(const char* name, TOperator op);
215 void relateToExtension(const char* name, const TString& ext);
John Bauman66b8ab22014-05-06 15:57:45 -0400216
217protected:
218 tLevel level;
John Baumand4ae8632014-05-06 16:18:33 -0400219 static int uniqueId; // for unique identification in code generation
John Bauman66b8ab22014-05-06 15:57:45 -0400220};
221
Nicolas Capense2858652015-02-18 15:30:51 -0500222enum ESymbolLevel
223{
Nicolas Capens3d7f6ed2015-02-18 16:34:50 -0500224 COMMON_BUILTINS,
225 ESSL1_BUILTINS,
226 ESSL3_BUILTINS,
227 LAST_BUILTIN_LEVEL = ESSL3_BUILTINS,
228 GLOBAL_LEVEL
Nicolas Capense2858652015-02-18 15:30:51 -0500229};
230
Nicolas Capens8fa9d232015-02-19 15:53:16 -0500231inline 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
242inline 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
253inline 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
274inline 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 Capens0a7f0c22015-02-18 14:47:31 -0500295class TSymbolTable
296{
John Bauman66b8ab22014-05-06 15:57:45 -0400297public:
John Baumand4ae8632014-05-06 16:18:33 -0400298 TSymbolTable()
John Bauman66b8ab22014-05-06 15:57:45 -0400299 {
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 Capense2858652015-02-18 15:30:51 -0500309 while(currentLevel() > LAST_BUILTIN_LEVEL)
310 {
311 pop();
312 }
John Bauman66b8ab22014-05-06 15:57:45 -0400313 }
314
Nicolas Capense2858652015-02-18 15:30:51 -0500315 bool isEmpty() { return table.empty(); }
316 bool atBuiltInLevel() { return currentLevel() <= LAST_BUILTIN_LEVEL; }
317 bool atGlobalLevel() { return currentLevel() <= GLOBAL_LEVEL; }
John Bauman66b8ab22014-05-06 15:57:45 -0400318 void push()
319 {
320 table.push_back(new TSymbolTableLevel);
321 precisionStack.push_back( PrecisionStackLevel() );
322 }
323
324 void pop()
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500325 {
326 delete table[currentLevel()];
327 table.pop_back();
John Bauman66b8ab22014-05-06 15:57:45 -0400328 precisionStack.pop_back();
329 }
330
Nicolas Capensd603ecd2015-02-18 14:52:21 -0500331 bool declare(TSymbol &symbol)
John Bauman66b8ab22014-05-06 15:57:45 -0400332 {
Nicolas Capensd603ecd2015-02-18 14:52:21 -0500333 return insert(currentLevel(), symbol);
334 }
335
Nicolas Capense2858652015-02-18 15:30:51 -0500336 bool insert(ESymbolLevel level, TSymbol &symbol)
Nicolas Capensd603ecd2015-02-18 14:52:21 -0500337 {
338 return table[level]->insert(symbol);
John Bauman66b8ab22014-05-06 15:57:45 -0400339 }
340
Nicolas Capense2858652015-02-18 15:30:51 -0500341 bool insertConstInt(ESymbolLevel level, const char *name, int value)
John Baumand4ae8632014-05-06 16:18:33 -0400342 {
343 TVariable *constant = new TVariable(NewPoolTString(name), TType(EbtInt, EbpUndefined, EvqConst, 1));
344 constant->getConstPointer()->setIConst(value);
Nicolas Capense2858652015-02-18 15:30:51 -0500345 return insert(level, *constant);
John Baumand4ae8632014-05-06 16:18:33 -0400346 }
347
Nicolas Capensf8a4cba2015-02-18 17:30:46 -0500348 void insertBuiltIn(ESymbolLevel level, TType *rvalue, const char *name, TType *ptype1, TType *ptype2 = 0, TType *ptype3 = 0, TType *ptype4 = 0)
John Baumand4ae8632014-05-06 16:18:33 -0400349 {
Nicolas Capensf8a4cba2015-02-18 17:30:46 -0500350 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 Capens8fa9d232015-02-19 15:53:16 -0500382 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 Capensf8a4cba2015-02-18 17:30:46 -0500405
John Baumand4ae8632014-05-06 16:18:33 -0400406 TFunction *function = new TFunction(NewPoolTString(name), *rvalue);
407
Nicolas Capens434311c2014-05-28 19:23:55 -0400408 TParameter param1 = {0, ptype1};
John Baumand4ae8632014-05-06 16:18:33 -0400409 function->addParameter(param1);
410
Nicolas Capens434311c2014-05-28 19:23:55 -0400411 if(ptype2)
John Baumand4ae8632014-05-06 16:18:33 -0400412 {
Nicolas Capens434311c2014-05-28 19:23:55 -0400413 TParameter param2 = {0, ptype2};
John Baumand4ae8632014-05-06 16:18:33 -0400414 function->addParameter(param2);
415 }
416
Nicolas Capens434311c2014-05-28 19:23:55 -0400417 if(ptype3)
John Baumand4ae8632014-05-06 16:18:33 -0400418 {
Nicolas Capens434311c2014-05-28 19:23:55 -0400419 TParameter param3 = {0, ptype3};
John Baumand4ae8632014-05-06 16:18:33 -0400420 function->addParameter(param3);
421 }
422
Nicolas Capens8fa9d232015-02-19 15:53:16 -0500423 if(ptype4)
424 {
425 TParameter param4 = {0, ptype4};
426 function->addParameter(param4);
427 }
428
Nicolas Capensf8a4cba2015-02-18 17:30:46 -0500429 insert(level, *function);
John Bauman66b8ab22014-05-06 15:57:45 -0400430 }
431
Nicolas Capense2858652015-02-18 15:30:51 -0500432 TSymbol *find(const TString &name, int shaderVersion, bool *builtIn = false, bool *sameScope = false) const;
433 TSymbol *findBuiltIn(const TString &name, int shaderVersion) const;
John Bauman66b8ab22014-05-06 15:57:45 -0400434
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500435 TSymbolTableLevel *getOuterLevel() const
436 {
Nicolas Capense2858652015-02-18 15:30:51 -0500437 assert(currentLevel() >= 1);
John Bauman66b8ab22014-05-06 15:57:45 -0400438 return table[currentLevel() - 1];
439 }
440
Nicolas Capense2858652015-02-18 15:30:51 -0500441 void relateToOperator(ESymbolLevel level, const char *name, TOperator op)
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500442 {
Nicolas Capense2858652015-02-18 15:30:51 -0500443 table[level]->relateToOperator(name, op);
John Bauman66b8ab22014-05-06 15:57:45 -0400444 }
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500445
Nicolas Capense2858652015-02-18 15:30:51 -0500446 void relateToExtension(ESymbolLevel level, const char *name, const TString &ext)
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500447 {
Nicolas Capense2858652015-02-18 15:30:51 -0500448 table[level]->relateToExtension(name, ext);
John Bauman66b8ab22014-05-06 15:57:45 -0400449 }
John Bauman66b8ab22014-05-06 15:57:45 -0400450
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500451 bool setDefaultPrecision(const TPublicType &type, TPrecision prec)
452 {
John Baumand4ae8632014-05-06 16:18:33 -0400453 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 Bauman66b8ab22014-05-06 15:57:45 -0400459 int indexOfLastElement = static_cast<int>(precisionStack.size()) - 1;
John Baumand4ae8632014-05-06 16:18:33 -0400460 precisionStack[indexOfLastElement][type.type] = prec; // Uses map operator [], overwrites the current value
461 return true;
John Bauman66b8ab22014-05-06 15:57:45 -0400462 }
463
464 // Searches down the precisionStack for a precision qualifier for the specified TBasicType
Nicolas Capens3c20f802015-02-17 17:17:20 -0500465 TPrecision getDefaultPrecision( TBasicType type)
466 {
467 // unsigned integers use the same precision as signed
468 if (type == EbtUInt) type = EbtInt;
469
John Bauman66b8ab22014-05-06 15:57:45 -0400470 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 Capens0a7f0c22015-02-18 14:47:31 -0500486protected:
Nicolas Capense2858652015-02-18 15:30:51 -0500487 ESymbolLevel currentLevel() const { return static_cast<ESymbolLevel>(table.size() - 1); }
John Bauman66b8ab22014-05-06 15:57:45 -0400488
489 std::vector<TSymbolTableLevel*> table;
490 typedef std::map< TBasicType, TPrecision > PrecisionStackLevel;
491 std::vector< PrecisionStackLevel > precisionStack;
John Bauman66b8ab22014-05-06 15:57:45 -0400492};
493
494#endif // _SYMBOL_TABLE_INCLUDED_