Initializer cleanup

src/OpenGL/compiler/ParseHelper.h

@@ -45,7 +45,10 @@ struct TParseContext {
             shaderVersion(100),
             directiveHandler(ext, diagnostics, shaderVersion),
             preprocessor(&diagnostics, &directiveHandler),
-            scanner(NULL) {  }
+            scanner(NULL),
+            mDeferredSingleDeclarationErrorCheck(false),
+            mUsesFragData(false),
+            mUsesFragColor(false) {  }
     TIntermediate& intermediate; // to hold and build a parse tree
     TSymbolTable& symbolTable;   // symbol table that goes with the language currently being parsed
     GLenum shaderType;              // vertex or fragment language (future: pack or unpack)
@@ -79,6 +82,9 @@ struct TParseContext {
     void trace(const char* str);
     void recover();
 
+	// This method is guaranteed to succeed, even if no variable with 'name' exists.
+	const TVariable *getNamedVariable(const TSourceLoc &location, const TString *name, const TSymbol *symbol);
+
     bool parseVectorFields(const TString&, int vecSize, TVectorFields&, int line);
     bool parseMatrixFields(const TString&, int matCols, int matRows, TMatrixFields&, int line);
 
@@ -96,16 +102,18 @@ struct TParseContext {
     bool arrayQualifierErrorCheck(int line, TPublicType type);
     bool arrayTypeErrorCheck(int line, TPublicType type);
     bool arrayErrorCheck(int line, TString& identifier, TPublicType type, TVariable*& variable);
-    bool voidErrorCheck(int, const TString&, const TPublicType&);
+    bool voidErrorCheck(int, const TString&, const TBasicType&);
     bool boolErrorCheck(int, const TIntermTyped*);
     bool boolErrorCheck(int, const TPublicType&);
     bool samplerErrorCheck(int line, const TPublicType& pType, const char* reason);
+	bool locationDeclaratorListCheck(const TSourceLoc &line, const TPublicType &pType);
     bool structQualifierErrorCheck(int line, const TPublicType& pType);
     bool parameterSamplerErrorCheck(int line, TQualifier qualifier, const TType& type);
     bool nonInitConstErrorCheck(int line, TString& identifier, TPublicType& type, bool array);
-    bool nonInitErrorCheck(int line, TString& identifier, TPublicType& type, TVariable*& variable);
+    bool nonInitErrorCheck(int line, const TString& identifier, TPublicType& type);
     bool paramErrorCheck(int line, TQualifier qualifier, TQualifier paramQualifier, TType* type);
     bool extensionErrorCheck(int line, const TString&);
+	bool singleDeclarationErrorCheck(const TPublicType &publicType, const TSourceLoc &identifierLocation);
     bool layoutLocationErrorCheck(const TSourceLoc& location, const TLayoutQualifier &layoutQualifier);
     bool functionCallLValueErrorCheck(const TFunction *fnCandidate, TIntermAggregate *);
 
@@ -119,12 +127,39 @@ struct TParseContext {
     bool containsSampler(TType& type);
     bool areAllChildConst(TIntermAggregate* aggrNode);
     const TFunction* findFunction(int line, TFunction* pfnCall, bool *builtIn = 0);
-    bool executeInitializer(TSourceLoc line, TString& identifier, TPublicType& pType,
+    bool executeInitializer(TSourceLoc line, const TString& identifier, const TPublicType& pType,
                             TIntermTyped* initializer, TIntermNode*& intermNode, TVariable* variable = 0);
 
     TPublicType addFullySpecifiedType(TQualifier qualifier, bool invariant, TLayoutQualifier layoutQualifier, const TPublicType &typeSpecifier);
     bool arraySetMaxSize(TIntermSymbol*, TType*, int, bool, TSourceLoc);
 
+	TIntermAggregate *parseSingleDeclaration(TPublicType &publicType, const TSourceLoc &identifierOrTypeLocation, const TString &identifier);
+	TIntermAggregate *parseSingleArrayDeclaration(TPublicType &publicType, const TSourceLoc &identifierLocation, const TString &identifier,
+	                                              const TSourceLoc &indexLocation, TIntermTyped *indexExpression);
+	TIntermAggregate *parseSingleInitDeclaration(const TPublicType &publicType, const TSourceLoc &identifierLocation, const TString &identifier,
+	                                             const TSourceLoc &initLocation, TIntermTyped *initializer);
+
+	// Parse a declaration like "type a[n] = initializer"
+	// Note that this does not apply to declarations like "type[n] a = initializer"
+	TIntermAggregate *parseSingleArrayInitDeclaration(TPublicType &publicType, const TSourceLoc &identifierLocation, const TString &identifier,
+	                                                  const TSourceLoc &indexLocation, TIntermTyped *indexExpression,
+	                                                  const TSourceLoc &initLocation, TIntermTyped *initializer);
+
+	TIntermAggregate *parseInvariantDeclaration(const TSourceLoc &invariantLoc, const TSourceLoc &identifierLoc, const TString *identifier,
+	                                            const TSymbol *symbol);
+
+	TIntermAggregate *parseDeclarator(TPublicType &publicType, TIntermAggregate *aggregateDeclaration, const TSourceLoc &identifierLocation,
+	                                  const TString &identifier);
+	TIntermAggregate *parseArrayDeclarator(TPublicType &publicType, TIntermAggregate *aggregateDeclaration, const TSourceLoc &identifierLocation,
+	                                       const TString &identifier, const TSourceLoc &arrayLocation, TIntermTyped *indexExpression);
+	TIntermAggregate *parseInitDeclarator(const TPublicType &publicType, TIntermAggregate *aggregateDeclaration, const TSourceLoc &identifierLocation,
+	                                      const TString &identifier, const TSourceLoc &initLocation, TIntermTyped *initializer);
+
+	// Parse a declarator like "a[n] = initializer"
+	TIntermAggregate *parseArrayInitDeclarator(const TPublicType &publicType, TIntermAggregate *aggregateDeclaration, const TSourceLoc &identifierLocation,
+	                                           const TString &identifier, const TSourceLoc &indexLocation, TIntermTyped *indexExpression,
+                                               const TSourceLoc &initLocation, TIntermTyped *initializer);
+
     TIntermTyped* addConstructor(TIntermNode*, const TType*, TOperator, TFunction*, TSourceLoc);
     TIntermTyped* foldConstConstructor(TIntermAggregate* aggrNode, const TType& type);
     TIntermTyped* addConstVectorNode(TVectorFields&, TIntermTyped*, TSourceLoc);
@@ -154,12 +189,18 @@ struct TParseContext {
 	TIntermTyped *addUnaryMathLValue(TOperator op, TIntermTyped *child, const TSourceLoc &loc);
 
 private:
+	bool declareVariable(const TSourceLoc &line, const TString &identifier, const TType &type, TVariable **variable);
+
 	// The funcReturnType parameter is expected to be non-null when the operation is a built-in function.
 	// It is expected to be null for other unary operators.
 	TIntermTyped *createUnaryMath(TOperator op, TIntermTyped *child, const TSourceLoc &loc, const TType *funcReturnType);
 
 	// Return true if the checks pass
 	bool binaryOpCommonCheck(TOperator op, TIntermTyped *left, TIntermTyped *right, const TSourceLoc &loc);
+
+	bool mDeferredSingleDeclarationErrorCheck;
+	bool mUsesFragData; // track if we are using both gl_FragData and gl_FragColor
+	bool mUsesFragColor;
 };
 
 int PaParseStrings(int count, const char* const string[], const int length[],

src/OpenGL/compiler/SymbolTable.h

@@ -38,6 +38,7 @@
 
 #include "InfoSink.h"
 #include "intermediate.h"
+#include <set>
 
 //
 // Symbol base class.  (Can build functions or variables out of these...)
@@ -300,6 +301,7 @@ class TSymbolTable
 {
 public:
     TSymbolTable()
+        : mGlobalInvariant(false)
     {
         //
         // The symbol table cannot be used until push() is called, but
@@ -483,12 +485,34 @@ public:
         return prec;
     }
 
+	// This records invariant varyings declared through
+	// "invariant varying_name;".
+	void addInvariantVarying(const std::string &originalName)
+	{
+		mInvariantVaryings.insert(originalName);
+	}
+	// If this returns false, the varying could still be invariant
+	// if it is set as invariant during the varying variable
+	// declaration - this piece of information is stored in the
+	// variable's type, not here.
+	bool isVaryingInvariant(const std::string &originalName) const
+	{
+		return (mGlobalInvariant ||
+			mInvariantVaryings.count(originalName) > 0);
+	}
+
+	void setGlobalInvariant() { mGlobalInvariant = true; }
+	bool getGlobalInvariant() const { return mGlobalInvariant; }
+
 protected:
     ESymbolLevel currentLevel() const { return static_cast<ESymbolLevel>(table.size() - 1); }
 
     std::vector<TSymbolTableLevel*> table;
     typedef std::map< TBasicType, TPrecision > PrecisionStackLevel;
     std::vector< PrecisionStackLevel > precisionStack;
+
+	std::set<std::string> mInvariantVaryings;
+	bool mGlobalInvariant;
 };
 
 #endif // _SYMBOL_TABLE_INCLUDED_

src/OpenGL/compiler/intermediate.h

@@ -31,6 +31,7 @@ enum TOperator {
     EOpParameters,      // an aggregate listing the parameters to a function
 
     EOpDeclaration,
+    EOpInvariantDeclaration, // Specialized declarations for attributing invariance
     EOpPrototype,
 
     //