Split builtin symbols over multiple levels.

src/OpenGL/compiler/SymbolTable.cpp

@@ -181,6 +181,38 @@ void TSymbolTableLevel::relateToExtension(const char* name, const TString& ext)
     }
 }
 
+TSymbol *TSymbolTable::find(const TString &name, int shaderVersion, bool *builtIn, bool *sameScope) const
+{
+    int level = currentLevel();
+    TSymbol *symbol = nullptr;
+
+    do
+    {
+        symbol = table[level]->find(name);
+        --level;
+    }
+    while(!symbol && level >= 0);
+
+    level++;
+
+    if(builtIn)
+    {
+        *builtIn = (level == 0);
+    }
+
+    if(sameScope)
+    {
+        *sameScope = (level == currentLevel());
+    }
+
+    return symbol;
+}
+
+TSymbol *TSymbolTable::findBuiltIn(const TString &name, int shaderVersion) const
+{
+    return table[0]->find(name);
+}
+
 TSymbol::TSymbol(const TSymbol& copyOf)
 {
     name = NewPoolTString(copyOf.name->c_str());

src/OpenGL/compiler/SymbolTable.h

@@ -219,6 +219,14 @@ protected:
 	static int uniqueId;     // for unique identification in code generation
 };
 
+enum ESymbolLevel
+{
+    COMMON_BUILTINS = 0,
+    ESSL1_BUILTINS = 0,
+    LAST_BUILTIN_LEVEL = ESSL1_BUILTINS,
+    GLOBAL_LEVEL = 1
+};
+
 class TSymbolTable
 {
 public:
@@ -233,19 +241,15 @@ public:
 
     ~TSymbolTable()
     {
-        // level 0 is always built In symbols, so we never pop that out
-        while (table.size() > 1)
+		while(currentLevel() > LAST_BUILTIN_LEVEL)
+		{
 			pop();
 		}
+    }
 
-    //
-    // When the symbol table is initialized with the built-ins, there should
-    // 'push' calls, so that built-ins are at level 0 and the shader
-    // globals are at level 1.
-    //
-    bool isEmpty() { return table.size() == 0; }
-    bool atBuiltInLevel() { return table.size() == 1; }
-    bool atGlobalLevel() { return table.size() <= 2; }
+    bool isEmpty() { return table.empty(); }
+    bool atBuiltInLevel() { return currentLevel() <= LAST_BUILTIN_LEVEL; }
+    bool atGlobalLevel() { return currentLevel() <= GLOBAL_LEVEL; }
     void push()
     {
         table.push_back(new TSymbolTableLevel);
@@ -264,19 +268,19 @@ public:
         return insert(currentLevel(), symbol);
     }
 
-    bool insert(int level, TSymbol &symbol)
+    bool insert(ESymbolLevel level, TSymbol &symbol)
     {
         return table[level]->insert(symbol);
     }
 
-	bool insertConstInt(const char *name, int value)
+	bool insertConstInt(ESymbolLevel level, const char *name, int value)
 	{
 		TVariable *constant = new TVariable(NewPoolTString(name), TType(EbtInt, EbpUndefined, EvqConst, 1));
 		constant->getConstPointer()->setIConst(value);
-		return insert(0, *constant);
+		return insert(level, *constant);
 	}
 
-	bool insertBuiltIn(TType *rvalue, const char *name, TType *ptype1, TType *ptype2 = 0, TType *ptype3 = 0)
+	bool insertBuiltIn(ESymbolLevel level, TType *rvalue, const char *name, TType *ptype1, TType *ptype2 = 0, TType *ptype3 = 0)
 	{
 		TFunction *function = new TFunction(NewPoolTString(name), *rvalue);
 
@@ -295,50 +299,26 @@ public:
 			function->addParameter(param3);
 		}
 
-		return insert(0, *function);
+		return insert(level, *function);
     }
 
-    TSymbol *find(const TString &name, int shaderVersion, bool *builtIn = false, bool *sameScope = false) const
-    {
-        int level = currentLevel();
-        TSymbol* symbol;
-        do {
-            symbol = table[level]->find(name);
-            --level;
-        } while (symbol == 0 && level >= 0);
-        level++;
-        if (builtIn)
-            *builtIn = level == 0;
-        if (sameScope)
-            *sameScope = level == currentLevel();
-        return symbol;
-    }
-
-    TSymbol *findBuiltIn(const TString &name, int shaderVersion) const
-    {
-        return table[0]->find(name);
-    }
-
-    TSymbolTableLevel *getGlobalLevel() const
-    {
-        assert(table.size() >= 2);
-        return table[1];
-    }
+    TSymbol *find(const TString &name, int shaderVersion, bool *builtIn = false, bool *sameScope = false) const;
+    TSymbol *findBuiltIn(const TString &name, int shaderVersion) const;
 
     TSymbolTableLevel *getOuterLevel() const
     {
-        assert(table.size() >= 2);
+        assert(currentLevel() >= 1);
         return table[currentLevel() - 1];
     }
 
-    void relateToOperator(const char* name, TOperator op)
+    void relateToOperator(ESymbolLevel level, const char *name, TOperator op)
     {
-        table[0]->relateToOperator(name, op);
+        table[level]->relateToOperator(name, op);
     }
 
-    void relateToExtension(const char* name, const TString& ext)
+    void relateToExtension(ESymbolLevel level, const char *name, const TString &ext)
     {
-        table[0]->relateToExtension(name, ext);
+        table[level]->relateToExtension(name, ext);
     }
 
     bool setDefaultPrecision(const TPublicType &type, TPrecision prec)
@@ -377,7 +357,7 @@ public:
     }
 
 protected:
-    int currentLevel() const { return static_cast<int>(table.size() - 1); }
+    ESymbolLevel currentLevel() const { return static_cast<ESymbolLevel>(table.size() - 1); }
 
     std::vector<TSymbolTableLevel*> table;
     typedef std::map< TBasicType, TPrecision > PrecisionStackLevel;