Added mechanism to predefine associated macros for extensions. Also refactored…

src/compiler/Common.h

@@ -71,6 +71,4 @@ public:
     TMap(const tAllocator& a) : std::map<K, D, CMP, tAllocator>(std::map<K, D, CMP, tAllocator>::key_compare(), a) {}
 };
 
-typedef TMap<TString, TString> TPragmaTable;
-
 #endif // _COMMON_INCLUDED_

src/compiler/ExtensionBehavior.h

+//
+// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+#ifndef _EXTENSION_BEHAVIOR_INCLUDED_
+#define _EXTENSION_BEHAVIOR_INCLUDED_
+
+#include "compiler/Common.h"
+
+typedef enum {
+    EBhRequire,
+    EBhEnable,
+    EBhWarn,
+    EBhDisable
+} TBehavior;
+
+typedef TMap<TString, TBehavior> TExtensionBehavior;
+
+#endif // _EXTENSION_TABLE_INCLUDED_

src/compiler/Initialize.cpp

@@ -619,3 +619,9 @@ void IdentifyBuiltIns(EShLanguage language, EShSpec spec, const TBuiltInResource
     }
 }
 
+void InitExtensionBehavior(const TBuiltInResource& resources,
+                           TExtensionBehavior& extBehavior)
+{
+    if (resources.OES_standard_derivatives)
+        extBehavior["GL_OES_standard_derivatives"] = EBhDisable;
+}

src/compiler/Initialize.h

@@ -27,7 +27,11 @@ protected:
 void IdentifyBuiltIns(EShLanguage language, EShSpec spec, const TBuiltInResource& resources,
                       TSymbolTable& symbolTable);
 
+void InitExtensionBehavior(const TBuiltInResource& resources,
+                           TExtensionBehavior& extensionBehavior);
+
 extern "C" int InitPreprocessor(void);
 extern "C" int FinalizePreprocessor(void);
+extern "C" void PredefineIntMacro(const char *name, int value);
 
 #endif // _INITIALIZE_INCLUDED_

src/compiler/ParseHelper.cpp

@@ -1375,17 +1375,6 @@ TIntermTyped* TParseContext::addConstStruct(TString& identifier, TIntermTyped* n
     return typedNode;
 }
 
-//
-// Initialize all supported extensions to disable
-//
-void TParseContext::initializeExtensionBehavior()
-{
-    //
-    // example code: extensionBehavior["test"] = EBhDisable; // where "test" is the name of 
-    // supported extension
-    //
-}
-
 OS_TLSIndex GlobalParseContextIndex = OS_INVALID_TLS_INDEX;
 
 bool InitializeParseContextIndex()

src/compiler/ParseHelper.h

@@ -6,9 +6,10 @@
 #ifndef _PARSER_HELPER_INCLUDED_
 #define _PARSER_HELPER_INCLUDED_
 
+#include "compiler/ExtensionBehavior.h"
+#include "compiler/localintermediate.h"
 #include "compiler/ShHandle.h"
 #include "compiler/SymbolTable.h"
-#include "compiler/localintermediate.h"
 
 struct TMatrixFields {
     bool wholeRow;
@@ -17,13 +18,6 @@ struct TMatrixFields {
     int col;
 };
 
-typedef enum {
-    EBhRequire,
-    EBhEnable,
-    EBhWarn,
-    EBhDisable
-} TBehavior;
-
 struct TPragma {
     TPragma(bool o, bool d) : optimize(o), debug(d) { }
     bool optimize;
@@ -36,12 +30,13 @@ struct TPragma {
 // they can be passed to the parser without needing a global.
 //
 struct TParseContext {
-    TParseContext(TSymbolTable& symt, TIntermediate& interm, EShLanguage l, EShSpec s, TInfoSink& is) :
-            intermediate(interm), symbolTable(symt), infoSink(is), language(l), spec(s), treeRoot(0),
+    TParseContext(TSymbolTable& symt, const TExtensionBehavior& ext, TIntermediate& interm, EShLanguage l, EShSpec s, TInfoSink& is) :
+            intermediate(interm), symbolTable(symt), extensionBehavior(ext), infoSink(is), language(l), spec(s), treeRoot(0),
             recoveredFromError(false), numErrors(0), lexAfterType(false), loopNestingLevel(0),
             inTypeParen(false), contextPragma(true, false) {  }
     TIntermediate& intermediate; // to hold and build a parse tree
     TSymbolTable& symbolTable;   // symbol table that goes with the language currently being parsed
+    TExtensionBehavior extensionBehavior;  // mapping between supported extensions and current behavior.
     TInfoSink& infoSink;
     EShLanguage language;        // vertex or fragment language (future: pack or unpack)
     EShSpec spec;                // The language specification compiler conforms to - GLES2 or WebGL.
@@ -53,8 +48,6 @@ struct TParseContext {
     bool inTypeParen;            // true if in parentheses, looking only for an identifier
     const TType* currentFunctionType;  // the return type of the function that's currently being parsed
     bool functionReturnsValue;   // true if a non-void function has a return
-    TMap<TString, TBehavior> extensionBehavior;
-    void initializeExtensionBehavior();
 
     void error(TSourceLoc, const char *szReason, const char *szToken,
                const char *szExtraInfoFormat, ...);

src/compiler/ShHandle.h

@@ -16,6 +16,7 @@
 
 #include "GLSLANG/ShaderLang.h"
 
+#include "compiler/ExtensionBehavior.h"
 #include "compiler/InfoSink.h"
 #include "compiler/SymbolTable.h"
 
@@ -44,6 +45,7 @@ public:
     EShLanguage getLanguage() const { return language; }
     EShSpec getSpec() const { return spec; }
     TSymbolTable& getSymbolTable() { return symbolTable; }
+    TExtensionBehavior& getExtensionBehavior() { return extensionBehavior; }
     TInfoSink& getInfoSink() { return infoSink; }
 
     virtual bool compile(TIntermNode* root) = 0;
@@ -57,6 +59,8 @@ protected:
     // Built-in symbol table for the given language, spec, and resources.
     // It is preserved from compile-to-compile.
     TSymbolTable symbolTable;
+    // Built-in extensions with default behavior.
+    TExtensionBehavior extensionBehavior;
     // Output sink.
     TInfoSink infoSink;
 };

src/compiler/ShaderLang.cpp

@@ -23,7 +23,8 @@ static bool InitializeSymbolTable(
         TInfoSink& infoSink, TSymbolTable& symbolTable)
 {
     TIntermediate intermediate(infoSink);
-    TParseContext parseContext(symbolTable, intermediate, language, spec, infoSink);
+    TExtensionBehavior extBehavior;
+    TParseContext parseContext(symbolTable, extBehavior, intermediate, language, spec, infoSink);
 
     GlobalParseContext = &parseContext;
 
@@ -79,6 +80,14 @@ static bool GenerateBuiltInSymbolTable(
     return InitializeSymbolTable(builtIns.getBuiltInStrings(), language, spec, resources, infoSink, symbolTable);
 }
 
+static void DefineExtensionMacros(const TExtensionBehavior& extBehavior)
+{
+    for (TExtensionBehavior::const_iterator iter = extBehavior.begin();
+         iter != extBehavior.end(); ++iter) {
+        PredefineIntMacro(iter->first.c_str(), 1);
+    }
+}
+
 //
 // This is the platform independent interface between an OGL driver
 // and the shading language compiler.
@@ -144,6 +153,7 @@ ShHandle ShConstructCompiler(EShLanguage language, EShSpec spec, const TBuiltInR
         ShDestruct(base);
         return 0;
     }
+    InitExtensionBehavior(*resources, compiler->getExtensionBehavior());
 
     return reinterpret_cast<void*>(base);
 }
@@ -196,14 +206,16 @@ int ShCompile(
 
     TIntermediate intermediate(infoSink);
     TSymbolTable& symbolTable = compiler->getSymbolTable();
+    const TExtensionBehavior& extBehavior = compiler->getExtensionBehavior();
 
-    TParseContext parseContext(symbolTable, intermediate, compiler->getLanguage(), compiler->getSpec(), infoSink);
-    parseContext.initializeExtensionBehavior();
+    TParseContext parseContext(symbolTable, extBehavior, intermediate,
+        compiler->getLanguage(), compiler->getSpec(), infoSink);
     GlobalParseContext = &parseContext;
  
     setInitialState();
 
     InitPreprocessor();
+    DefineExtensionMacros(extBehavior);
     //
     // Parse the application's shaders.  All the following symbol table
     // work will be throw-away, so push a new allocation scope that can

src/compiler/intermediate.h

@@ -404,6 +404,7 @@ protected:
 
 typedef TVector<TIntermNode*> TIntermSequence;
 typedef TVector<int> TQualifierList;
+typedef TMap<TString, TString> TPragmaTable;
 //
 // Nodes that operate on an arbitrary sized set of children.
 //