Add full support for uniforms with initializers, including intra-stage link validation of aggregate constant initializers.

This included 
 - encapsulating aggregate constants
 - removal of constant-aggregate comparison algorithms, instead using a flattened and direct std::vector comparison
 - adding structure type comparison for independently declared structures that still might match types



git-svn-id: https://cvs.khronos.org/svn/repos/ogl/trunk/ecosystem/public/sdk/tools/glslang@23274 e7fa87d3-cd2b-0410-9028-fcbf551c1848

glslang/Include/ConstantUnion.h

@@ -41,8 +41,8 @@ namespace glslang {
 
 class TConstUnion {
 public:
-
     POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
+
     void setIConst(int i)
     { 
         iConst = i; 
@@ -394,9 +394,9 @@ public:
         return returnValue;
     }
 
-    TBasicType getType() { return type; }
-private:
+    TBasicType getType() const { return type; }
 
+private:
     union  {
         int iConst;          // used for ivec, scalar ints
         unsigned int uConst; // used for uvec, scalar uints
@@ -407,6 +407,61 @@ private:
     TBasicType type;
 };
 
+// Encapsulate having a pointer to an array of TConstUnion,
+// which only needs to be allocated if it's size is going to be
+// bigger than 0.
+//
+// One convenience is being able to use [] to go inside the array, instead
+// of C++ assuming it as an array of pointers to vectors.
+//
+// General usage is that the size is known up front, and it is 
+// created once with the proper size.
+//
+class TConstUnionArray {
+public:
+    POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
+
+    TConstUnionArray() { unionArray = 0; }
+
+    explicit TConstUnionArray(int size)
+    {
+        if (size == 0)
+            unionArray = 0;
+        else
+            unionArray = new TVector<TConstUnion>(size);
+    }
+    TConstUnionArray(const TConstUnionArray& a) : unionArray(a.unionArray) { }
+    TConstUnionArray(const TConstUnionArray& a, int start, int size)
+    {
+        unionArray = new TVector<TConstUnion>(size);
+        for (int i = 0; i < size; ++i)
+            (*unionArray)[i] = a[start + i];
+    }
+
+    // Use this constructor for a smear operation
+    TConstUnionArray(int size, const TConstUnion& val)
+    {
+        unionArray = new TVector<TConstUnion>(size, val);
+    }
+
+    TConstUnion& operator[](int index) { return (*unionArray)[index]; }
+    const TConstUnion& operator[](int index) const { return (*unionArray)[index]; }
+    bool operator==(const TConstUnionArray& rhs) const
+    {
+        // this includes the case that both are unallocated
+        if (unionArray == rhs.unionArray)
+            return true;
+
+        return *unionArray == *rhs.unionArray;
+    }
+    bool operator!=(const TConstUnionArray& rhs) const { return ! operator==(rhs); }
+
+    bool empty() const { return unionArray == 0; }
+
+protected:
+    TVector<TConstUnion>* unionArray;
+};
+
 } // end namespace glslang
 
 #endif // _CONSTANT_UNION_INCLUDED_