Simplified TType class by carving out TStructure and TField.

src/compiler/FlagStd140Structs.cpp

@@ -55,11 +55,11 @@ bool FlagStd140Structs::isInStd140InterfaceBlock(TIntermTyped *node) const
 
     const TType &type = node->getType();
 
-    if (type.isInterfaceBlockMember() || type.getBasicType() == EbtInterfaceBlock)
-    {
     // determine if we are in the standard layout
-        const TType &interfaceBlockType = (type.isInterfaceBlockMember() ? *type.getInterfaceBlockType() : type);
-        return (interfaceBlockType.getLayoutQualifier().blockStorage == EbsStd140);
+    const TInterfaceBlock *interfaceBlock = type.getInterfaceBlock();
+    if (interfaceBlock)
+    {
+        return (interfaceBlock->blockStorage() == EbsStd140);
     }
 
     return false;

src/compiler/Initialize.cpp

@@ -447,19 +447,18 @@ void InsertBuiltInFunctions(ShShaderType type, ShShaderSpec spec, const ShBuiltI
     //
     // Depth range in window coordinates
     //
-    TTypeList *members = NewPoolTTypeList();
-    TTypeLine near = {new TType(EbtFloat, EbpHigh, EvqGlobal, 1), 0};
-    TTypeLine far = {new TType(EbtFloat, EbpHigh, EvqGlobal, 1), 0};
-    TTypeLine diff = {new TType(EbtFloat, EbpHigh, EvqGlobal, 1), 0};
-    near.type->setFieldName("near");
-    far.type->setFieldName("far");
-    diff.type->setFieldName("diff");
-    members->push_back(near);
-    members->push_back(far);
-    members->push_back(diff);
-    TVariable *depthRangeParameters = new TVariable(NewPoolTString("gl_DepthRangeParameters"), TType(members, "gl_DepthRangeParameters"), true);
+    TFieldList *fields = NewPoolTFieldList();
+    TSourceLoc zeroSourceLoc = {0};
+    TField *near = new TField(new TType(EbtFloat, EbpHigh, EvqGlobal, 1), NewPoolTString("near"), zeroSourceLoc);
+    TField *far = new TField(new TType(EbtFloat, EbpHigh, EvqGlobal, 1), NewPoolTString("far"), zeroSourceLoc);
+    TField *diff = new TField(new TType(EbtFloat, EbpHigh, EvqGlobal, 1), NewPoolTString("diff"), zeroSourceLoc);
+    fields->push_back(near);
+    fields->push_back(far);
+    fields->push_back(diff);
+    TStructure *depthRangeStruct = new TStructure(NewPoolTString("gl_DepthRangeParameters"), fields);
+    TVariable *depthRangeParameters = new TVariable(&depthRangeStruct->name(), depthRangeStruct, true);
     symbolTable.insert(COMMON_BUILTINS, *depthRangeParameters);
-    TVariable *depthRange = new TVariable(NewPoolTString("gl_DepthRange"), TType(members, "gl_DepthRangeParameters"));
+    TVariable *depthRange = new TVariable(NewPoolTString("gl_DepthRange"), TType(depthRangeStruct));
     depthRange->setQualifier(EvqUniform);
     symbolTable.insert(COMMON_BUILTINS, *depthRange);
 

src/compiler/Intermediate.cpp

@@ -1142,16 +1142,16 @@ bool TIntermBinary::promote(TInfoSink& infoSink)
 
 bool CompareStruct(const TType& leftNodeType, ConstantUnion* rightUnionArray, ConstantUnion* leftUnionArray)
 {
-    const TTypeList* fields = leftNodeType.getStruct();
+    const TFieldList& fields = leftNodeType.getStruct()->fields();
 
-    size_t structSize = fields->size();
+    size_t structSize = fields.size();
     size_t index = 0;
 
     for (size_t j = 0; j < structSize; j++) {
-        size_t size = (*fields)[j].type->getObjectSize();
+        size_t size = fields[j]->type()->getObjectSize();
         for (size_t i = 0; i < size; i++) {
-            if ((*fields)[j].type->getBasicType() == EbtStruct) {
-                if (!CompareStructure(*(*fields)[j].type, &rightUnionArray[index], &leftUnionArray[index]))
+            if (fields[j]->type()->getBasicType() == EbtStruct) {
+                if (!CompareStructure(*fields[j]->type(), &rightUnionArray[index], &leftUnionArray[index]))
                     return false;
             } else {
                 if (leftUnionArray[index] != rightUnionArray[index])

src/compiler/OutputGLSLBase.cpp

@@ -79,25 +79,9 @@ void TOutputGLSLBase::writeVariableType(const TType& type)
     if ((qualifier != EvqTemporary) && (qualifier != EvqGlobal))
         out << type.getQualifierString() << " ";
     // Declare the struct if we have not done so already.
-    if ((type.getBasicType() == EbtStruct) &&
-        (mDeclaredStructs.find(type.getTypeName()) == mDeclaredStructs.end()))
+    if ((type.getBasicType() == EbtStruct) && !structDeclared(type.getStruct()))
     {
-        out << "struct " << hashName(type.getTypeName()) << "{\n";
-        const TTypeList* structure = type.getStruct();
-        ASSERT(structure != NULL);
-        for (size_t i = 0; i < structure->size(); ++i)
-        {
-            const TType* fieldType = (*structure)[i].type;
-            ASSERT(fieldType != NULL);
-            if (writeVariablePrecision(fieldType->getPrecision()))
-                out << " ";
-            out << getTypeName(*fieldType) << " " << hashName(fieldType->getFieldName());
-            if (fieldType->isArray())
-                out << arrayBrackets(*fieldType);
-            out << ";\n";
-        }
-        out << "}";
-        mDeclaredStructs.insert(type.getTypeName());
+        declareStruct(type.getStruct());
     }
     else
     {
@@ -138,15 +122,16 @@ const ConstantUnion* TOutputGLSLBase::writeConstantUnion(const TType& type,
 
     if (type.getBasicType() == EbtStruct)
     {
-        out << hashName(type.getTypeName()) << "(";
-        const TTypeList* structure = type.getStruct();
-        ASSERT(structure != NULL);
-        for (size_t i = 0; i < structure->size(); ++i)
+        const TStructure* structure = type.getStruct();
+        out << hashName(structure->name()) << "(";
+
+        const TFieldList& fields = structure->fields();
+        for (size_t i = 0; i < fields.size(); ++i)
         {
-            const TType* fieldType = (*structure)[i].type;
+            const TType* fieldType = fields[i]->type();
             ASSERT(fieldType != NULL);
             pConstUnion = writeConstantUnion(*fieldType, pConstUnion);
-            if (i != structure->size() - 1) out << ", ";
+            if (i != fields.size() - 1) out << ", ";
         }
         out << ")";
     }
@@ -260,12 +245,18 @@ bool TOutputGLSLBase::visitBinary(Visit visit, TIntermBinary* node)
         case EOpIndexDirectStruct:
             if (visit == InVisit)
             {
+                // Here we are writing out "foo.bar", where "foo" is struct
+                // and "bar" is field. In AST, it is represented as a binary
+                // node, where left child represents "foo" and right child "bar".
+                // The node itself represents ".". The struct field "bar" is
+                // actually stored as an index into TStructure::fields.
                 out << ".";
-                // TODO(alokp): ASSERT
-                TString fieldName = node->getType().getFieldName();
+                const TStructure* structure = node->getLeft()->getType().getStruct();
+                const TIntermConstantUnion* index = node->getRight()->getAsConstantUnion();
+                const TField* field = structure->fields()[index->getIConst(0)];
 
-                const TType& structType = node->getLeft()->getType();
-                if (!mSymbolTable.findBuiltIn(structType.getTypeName()))
+                TString fieldName = field->name();
+                if (!mSymbolTable.findBuiltIn(structure->name()))
                     fieldName = hashName(fieldName);
 
                 out << fieldName;
@@ -596,7 +587,7 @@ bool TOutputGLSLBase::visitAggregate(Visit visit, TIntermAggregate* node)
             {
                 const TType& type = node->getType();
                 ASSERT(type.getBasicType() == EbtStruct);
-                out << hashName(type.getTypeName()) << "(";
+                out << hashName(type.getStruct()->name()) << "(";
             }
             else if (visit == InVisit)
             {
@@ -765,7 +756,7 @@ TString TOutputGLSLBase::getTypeName(const TType& type)
     else
     {
         if (type.getBasicType() == EbtStruct)
-            out << hashName(type.getTypeName());
+            out << hashName(type.getStruct()->name());
         else
             out << type.getBasicString();
     }
@@ -798,3 +789,29 @@ TString TOutputGLSLBase::hashFunctionName(const TString& mangled_name)
         return name;
     return hashName(name);
 }
+
+bool TOutputGLSLBase::structDeclared(const TStructure* structure) const
+{
+    return mDeclaredStructs.find(structure->name()) != mDeclaredStructs.end();
+}
+
+void TOutputGLSLBase::declareStruct(const TStructure* structure)
+{
+    TInfoSinkBase& out = objSink();
+
+    out << "struct " << hashName(structure->name()) << "{\n";
+    const TFieldList& fields = structure->fields();
+    for (size_t i = 0; i < fields.size(); ++i)
+    {
+        const TField* field = fields[i];
+        if (writeVariablePrecision(field->type()->getPrecision()))
+            out << " ";
+        out << getTypeName(*field->type()) << " " << hashName(field->name());
+        if (field->type()->isArray())
+            out << arrayBrackets(*field->type());
+        out << ";\n";
+    }
+    out << "}";
+
+    mDeclaredStructs.insert(structure->name());
+}

src/compiler/OutputGLSLBase.h

@@ -52,6 +52,9 @@ protected:
     TString hashFunctionName(const TString& mangled_name);
 
 private:
+    bool structDeclared(const TStructure* structure) const;
+    void declareStruct(const TStructure* structure);
+
     TInfoSinkBase& mObjSink;
     bool mDeclaringVariables;
 

src/compiler/OutputHLSL.cpp

@@ -241,15 +241,15 @@ int OutputHLSL::vectorSize(const TType &type) const
     return elementSize * arraySize;
 }
 
-TString OutputHLSL::interfaceBlockUniformName(const TType &interfaceBlockType, const TType &uniformType)
+TString OutputHLSL::interfaceBlockFieldString(const TInterfaceBlock &interfaceBlock, const TField &field)
 {
-    if (interfaceBlockType.hasInstanceName())
+    if (interfaceBlock.hasInstanceName())
     {
-        return interfaceBlockType.getTypeName() + "." + uniformType.getFieldName();
+        return interfaceBlock.name() + "." + field.name();
     }
     else
     {
-        return uniformType.getFieldName();
+        return field.name();
     }
 }
 
@@ -258,49 +258,115 @@ TString OutputHLSL::decoratePrivate(const TString &privateText)
     return "dx_" + privateText;
 }
 
-TString OutputHLSL::interfaceBlockStructName(const TType &interfaceBlockType)
+TString OutputHLSL::interfaceBlockStructNameString(const TInterfaceBlock &interfaceBlock)
 {
-    return decoratePrivate(interfaceBlockType.getTypeName()) + "_type";
+    return decoratePrivate(interfaceBlock.name()) + "_type";
 }
 
-TString OutputHLSL::interfaceBlockInstanceString(const TType& interfaceBlockType, unsigned int arrayIndex)
+TString OutputHLSL::interfaceBlockInstanceString(const TInterfaceBlock& interfaceBlock, unsigned int arrayIndex)
 {
-    if (!interfaceBlockType.hasInstanceName())
+    if (!interfaceBlock.hasInstanceName())
     {
         return "";
     }
-    else if (interfaceBlockType.isArray())
+    else if (interfaceBlock.isArray())
     {
-        return decoratePrivate(interfaceBlockType.getInstanceName()) + "_" + str(arrayIndex);
+        return decoratePrivate(interfaceBlock.instanceName()) + "_" + str(arrayIndex);
     }
     else
     {
-        return decorate(interfaceBlockType.getInstanceName());
+        return decorate(interfaceBlock.instanceName());
     }
 }
 
-TString OutputHLSL::interfaceBlockMemberTypeString(const TType &memberType, TLayoutBlockStorage blockStorage)
+TString OutputHLSL::interfaceBlockFieldTypeString(const TField &field, TLayoutBlockStorage blockStorage)
 {
-    const TLayoutMatrixPacking matrixPacking = memberType.getLayoutQualifier().matrixPacking;
+    const TType &fieldType = *field.type();
+    const TLayoutMatrixPacking matrixPacking = fieldType.getLayoutQualifier().matrixPacking;
     ASSERT(matrixPacking != EmpUnspecified);
 
-    if (memberType.isMatrix())
+    if (fieldType.isMatrix())
     {
         // Use HLSL row-major packing for GLSL column-major matrices
         const TString &matrixPackString = (matrixPacking == EmpRowMajor ? "column_major" : "row_major");
-        return matrixPackString + " " + typeString(memberType);
+        return matrixPackString + " " + typeString(fieldType);
     }
-    else if (memberType.getBasicType() == EbtStruct)
+    else if (fieldType.getStruct())
     {
         // Use HLSL row-major packing for GLSL column-major matrices
-        return structureTypeName(memberType, matrixPacking == EmpColumnMajor, blockStorage == EbsStd140);
+        return structureTypeName(*fieldType.getStruct(), matrixPacking == EmpColumnMajor, blockStorage == EbsStd140);
     }
     else
     {
-        return typeString(memberType);
+        return typeString(fieldType);
     }
 }
 
+TString OutputHLSL::interfaceBlockFieldString(const TInterfaceBlock &interfaceBlock, TLayoutBlockStorage blockStorage)
+{
+    TString hlsl;
+
+    int elementIndex = 0;
+
+    for (unsigned int typeIndex = 0; typeIndex < interfaceBlock.fields().size(); typeIndex++)
+    {
+        const TField &field = *interfaceBlock.fields()[typeIndex];
+        const TType &fieldType = *field.type();
+
+        if (blockStorage == EbsStd140)
+        {
+            // 2 and 3 component vector types in some cases need pre-padding
+            hlsl += std140PrePaddingString(fieldType, &elementIndex);
+        }
+
+        hlsl += "    " + interfaceBlockFieldTypeString(field, blockStorage) +
+                " " + decorate(field.name()) + arrayString(fieldType) + ";\n";
+
+        // must pad out after matrices and arrays, where HLSL usually allows itself room to pack stuff
+        if (blockStorage == EbsStd140)
+        {
+            const bool useHLSLRowMajorPacking = (fieldType.getLayoutQualifier().matrixPacking == EmpColumnMajor);
+            hlsl += std140PostPaddingString(fieldType, useHLSLRowMajorPacking);
+        }
+    }
+
+    return hlsl;
+}
+
+TString OutputHLSL::interfaceBlockStructString(const TInterfaceBlock &interfaceBlock)
+{
+    const TLayoutBlockStorage blockStorage = interfaceBlock.blockStorage();
+
+    return "struct " + interfaceBlockStructNameString(interfaceBlock) + "\n"
+           "{\n" +
+           interfaceBlockFieldString(interfaceBlock, blockStorage) +
+           "};\n\n";
+}
+
+TString OutputHLSL::interfaceBlockString(const TInterfaceBlock &interfaceBlock, unsigned int registerIndex, unsigned int arrayIndex)
+{
+    const TString &arrayIndexString =  (arrayIndex != GL_INVALID_INDEX ? decorate(str(arrayIndex)) : "");
+    const TString &blockName = interfaceBlock.name() + arrayIndexString;
+    TString hlsl;
+
+    hlsl += "cbuffer " + blockName + " : register(b" + str(registerIndex) + ")\n"
+            "{\n";
+
+    if (interfaceBlock.hasInstanceName())
+    {
+        hlsl += "    " + interfaceBlockStructNameString(interfaceBlock) + " " + interfaceBlockInstanceString(interfaceBlock, arrayIndex) + ";\n";
+    }
+    else
+    {
+        const TLayoutBlockStorage blockStorage = interfaceBlock.blockStorage();
+        hlsl += interfaceBlockFieldString(interfaceBlock, blockStorage);
+    }
+
+    hlsl += "};\n\n";
+
+    return hlsl;
+}
+
 TString OutputHLSL::std140PrePaddingString(const TType &type, int *elementIndex)
 {
     if (type.getBasicType() == EbtStruct || type.isMatrix() || type.isArray())
@@ -370,9 +436,9 @@ TString OutputHLSL::std140PostPaddingString(const TType &type, bool useHLSLRowMa
         const GLenum glType = glVariableType(type);
         numComponents = gl::MatrixComponentCount(glType, isRowMajorMatrix);
     }
-    else if (type.getBasicType() == EbtStruct)
+    else if (type.getStruct())
     {
-        const TString &structName = structureTypeName(type, useHLSLRowMajorPacking, true);
+        const TString &structName = structureTypeName(*type.getStruct(), useHLSLRowMajorPacking, true);
         numComponents = mStd140StructElementIndexes[structName];
 
         if (numComponents == 0)
@@ -394,72 +460,6 @@ TString OutputHLSL::std140PostPaddingString(const TType &type, bool useHLSLRowMa
     return padding;
 }
 
-TString OutputHLSL::interfaceBlockMemberString(const TTypeList &typeList, TLayoutBlockStorage blockStorage)
-{
-    TString hlsl;
-
-    int elementIndex = 0;
-
-    for (unsigned int typeIndex = 0; typeIndex < typeList.size(); typeIndex++)
-    {
-        const TType &memberType = *typeList[typeIndex].type;
-
-        if (blockStorage == EbsStd140)
-        {
-            // 2 and 3 component vector types in some cases need pre-padding
-            hlsl += std140PrePaddingString(memberType, &elementIndex);
-        }
-
-        hlsl += "    " + interfaceBlockMemberTypeString(memberType, blockStorage) +
-                " " + decorate(memberType.getFieldName()) + arrayString(memberType) + ";\n";
-
-        // must pad out after matrices and arrays, where HLSL usually allows itself room to pack stuff
-        if (blockStorage == EbsStd140)
-        {
-            const bool useHLSLRowMajorPacking = (memberType.getLayoutQualifier().matrixPacking == EmpColumnMajor);
-            hlsl += std140PostPaddingString(memberType, useHLSLRowMajorPacking);
-        }
-    }
-
-    return hlsl;
-}
-
-TString OutputHLSL::interfaceBlockStructString(const TType &interfaceBlockType)
-{
-    const TTypeList &typeList = *interfaceBlockType.getStruct();
-    const TLayoutBlockStorage blockStorage = interfaceBlockType.getLayoutQualifier().blockStorage;
-
-    return "struct " + interfaceBlockStructName(interfaceBlockType) + "\n"
-           "{\n" +
-           interfaceBlockMemberString(typeList, blockStorage) +
-           "};\n\n";
-}
-
-TString OutputHLSL::interfaceBlockString(const TType &interfaceBlockType, unsigned int registerIndex, unsigned int arrayIndex)
-{
-    const TString &arrayIndexString =  (arrayIndex != GL_INVALID_INDEX ? decorate(str(arrayIndex)) : "");
-    const TString &blockName = interfaceBlockType.getTypeName() + arrayIndexString;
-    TString hlsl;
-
-    hlsl += "cbuffer " + blockName + " : register(b" + str(registerIndex) + ")\n"
-            "{\n";
-
-    if (interfaceBlockType.hasInstanceName())
-    {
-        hlsl += "    " + interfaceBlockStructName(interfaceBlockType) + " " + interfaceBlockInstanceString(interfaceBlockType, arrayIndex) + ";\n";
-    }
-    else
-    {
-        const TTypeList &typeList = *interfaceBlockType.getStruct();
-        const TLayoutBlockStorage blockStorage = interfaceBlockType.getLayoutQualifier().blockStorage;
-        hlsl += interfaceBlockMemberString(typeList, blockStorage);
-    }
-
-    hlsl += "};\n\n";
-
-    return hlsl;
-}
-
 // Use the same layout for packed and shared
 void setBlockLayout(InterfaceBlock *interfaceBlock, BlockLayoutType newLayout)
 {
@@ -502,7 +502,7 @@ BlockLayoutType convertBlockLayoutType(TLayoutBlockStorage blockStorage)
     }
 }
 
-TString OutputHLSL::structInitializerString(int indent, const TTypeList &structMembers, const TString &structName)
+TString OutputHLSL::structInitializerString(int indent, const TStructure &structure, const TString &rhsStructName)
 {
     TString init;
 
@@ -521,19 +521,20 @@ TString OutputHLSL::structInitializerString(int indent, const TTypeList &structM
 
     init += preIndentString + "{\n";
 
-    for (unsigned int memberIndex = 0; memberIndex < structMembers.size(); memberIndex++)
+    const TFieldList &fields = structure.fields();
+    for (unsigned int fieldIndex = 0; fieldIndex < fields.size(); fieldIndex++)
     {
-        const TType &memberType = *structMembers[memberIndex].type;
-        const TString &fieldName = decorate(memberType.getFieldName());
+        const TField &field = *fields[fieldIndex];
+        const TString &fieldName = rhsStructName + "." + decorate(field.name());
+        const TType &fieldType = *field.type();
 
-        if (memberType.getBasicType() == EbtStruct)
+        if (fieldType.getStruct())
         {
-            const TTypeList &nestedStructMembers = *memberType.getStruct();
-            init += structInitializerString(indent + 1, nestedStructMembers, structName + "." + fieldName);
+            init += structInitializerString(indent + 1, *fieldType.getStruct(), fieldName);
         }
         else
         {
-            init += fullIndentString + structName + "." + fieldName + ",\n";
+            init += fullIndentString + fieldName + ",\n";
         }
     }
 
@@ -577,40 +578,39 @@ void OutputHLSL::header()
     for (ReferencedSymbols::const_iterator interfaceBlockIt = mReferencedInterfaceBlocks.begin(); interfaceBlockIt != mReferencedInterfaceBlocks.end(); interfaceBlockIt++)
     {
         const TType &nodeType = interfaceBlockIt->second->getType();
-        const TType &interfaceBlockType = nodeType.isInterfaceBlockMember() ? *nodeType.getInterfaceBlockType() : nodeType;
-        const TString &blockName = interfaceBlockType.getTypeName();
-        const TTypeList &typeList = *interfaceBlockType.getStruct();
+        const TInterfaceBlock &interfaceBlock = *nodeType.getInterfaceBlock();
+        const TFieldList &fieldList = interfaceBlock.fields();
 
-        const unsigned int arraySize = interfaceBlockType.isArray() ? interfaceBlockType.getArraySize() : 0;
-        sh::InterfaceBlock interfaceBlock(blockName.c_str(), arraySize, mInterfaceBlockRegister);
-        for (unsigned int typeIndex = 0; typeIndex < typeList.size(); typeIndex++)
+        unsigned int arraySize = static_cast<unsigned int>(interfaceBlock.arraySize());
+        sh::InterfaceBlock activeBlock(interfaceBlock.name().c_str(), arraySize, mInterfaceBlockRegister);
+        for (unsigned int typeIndex = 0; typeIndex < fieldList.size(); typeIndex++)
         {
-            const TType &memberType = *typeList[typeIndex].type;
-            const TString &fullUniformName = interfaceBlockUniformName(interfaceBlockType, memberType);
-            declareUniformToList(memberType, fullUniformName, typeIndex, interfaceBlock.activeUniforms);
+            const TField &field = *fieldList[typeIndex];
+            const TString &fullUniformName = interfaceBlockFieldString(interfaceBlock, field);
+            declareUniformToList(*field.type(), fullUniformName, typeIndex, activeBlock.activeUniforms);
         }
 
-        mInterfaceBlockRegister += std::max(1u, interfaceBlock.arraySize);
+        mInterfaceBlockRegister += std::max(1u, arraySize);
 
-        BlockLayoutType blockLayoutType = convertBlockLayoutType(interfaceBlockType.getLayoutQualifier().blockStorage);
-        setBlockLayout(&interfaceBlock, blockLayoutType);
-        mActiveInterfaceBlocks.push_back(interfaceBlock);
+        BlockLayoutType blockLayoutType = convertBlockLayoutType(interfaceBlock.blockStorage());
+        setBlockLayout(&activeBlock, blockLayoutType);
+        mActiveInterfaceBlocks.push_back(activeBlock);
 
-        if (interfaceBlockType.hasInstanceName())
+        if (interfaceBlock.hasInstanceName())
         {
-            interfaceBlocks += interfaceBlockStructString(interfaceBlockType);
+            interfaceBlocks += interfaceBlockStructString(interfaceBlock);
         }
 
         if (arraySize > 0)
         {
             for (unsigned int arrayIndex = 0; arrayIndex < arraySize; arrayIndex++)
             {
-                interfaceBlocks += interfaceBlockString(interfaceBlockType, interfaceBlock.registerIndex + arrayIndex, arrayIndex);
+                interfaceBlocks += interfaceBlockString(interfaceBlock, activeBlock.registerIndex + arrayIndex, arrayIndex);
             }
         }
         else
         {
-            interfaceBlocks += interfaceBlockString(interfaceBlockType, interfaceBlock.registerIndex, GL_INVALID_INDEX);
+            interfaceBlocks += interfaceBlockString(interfaceBlock, activeBlock.registerIndex, GL_INVALID_INDEX);
         }
     }
 
@@ -618,12 +618,11 @@ void OutputHLSL::header()
     {
         TIntermTyped *structNode = flaggedStructIt->first;
         const TString &mappedName = flaggedStructIt->second;
-        const TType &structType = structNode->getType();
-        const TTypeList &structMembers = *structType.getStruct();
+        const TStructure &structure = *structNode->getType().getStruct();
         const TString &originalName = mFlaggedStructOriginalNames[structNode];
 
-        flaggedStructs += "static " + decorate(structType.getTypeName()) + " " + mappedName + " =\n";
-        flaggedStructs += structInitializerString(0, structMembers, originalName);
+        flaggedStructs += "static " + decorate(structure.name()) + " " + mappedName + " =\n";
+        flaggedStructs += structInitializerString(0, structure, originalName);
         flaggedStructs += "\n";
     }
 
@@ -1463,23 +1462,19 @@ void OutputHLSL::visitSymbol(TIntermSymbol *node)
 
         if (qualifier == EvqUniform)
         {
-            if (node->getType().isInterfaceBlockMember())
-            {
-                const TString& interfaceBlockTypeName = node->getType().getInterfaceBlockType()->getTypeName();
-                mReferencedInterfaceBlocks[interfaceBlockTypeName] = node;
-                out << decorateUniform(name, node->getType());
-            }
-            else if (node->getBasicType() == EbtInterfaceBlock)
+            const TType& nodeType = node->getType();
+            const TInterfaceBlock* interfaceBlock = nodeType.getInterfaceBlock();
+
+            if (interfaceBlock)
             {
-                const TString& interfaceBlockTypeName = node->getType().getTypeName();
-                mReferencedInterfaceBlocks[interfaceBlockTypeName] = node;
-                out << decorateUniform(name, node->getType());
+                mReferencedInterfaceBlocks[interfaceBlock->name()] = node;
             }
             else
             {
                 mReferencedUniforms[name] = node;
-                out << decorateUniform(name, node->getType());
             }
+
+            out << decorateUniform(name, nodeType);
         }
         else if (qualifier == EvqAttribute || qualifier == EvqVertexInput)
         {
@@ -1624,13 +1619,18 @@ bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node)
         break;
       case EOpDivAssign:               outputTriplet(visit, "(", " /= ", ")");          break;
       case EOpIndexDirect:
-        if (node->getLeft()->getBasicType() == EbtInterfaceBlock)
+        {
+            const TType& leftType = node->getLeft()->getType();
+            if (leftType.isInterfaceBlock())
             {
                 if (visit == PreVisit)
                 {
-                const TType &interfaceBlockType = node->getLeft()->getType();
-                mReferencedInterfaceBlocks[interfaceBlockType.getInstanceName()] = node->getLeft()->getAsSymbolNode();
-                out << interfaceBlockInstanceString(interfaceBlockType, node->getRight()->getAsConstantUnion()->getIConst(0));
+                    TInterfaceBlock* interfaceBlock = leftType.getInterfaceBlock();
+                    const int arrayIndex = node->getRight()->getAsConstantUnion()->getIConst(0);
+
+                    mReferencedInterfaceBlocks[interfaceBlock->instanceName()] = node->getLeft()->getAsSymbolNode();
+                    out << interfaceBlockInstanceString(*interfaceBlock, arrayIndex);
+
                     return false;
                 }
             }
@@ -1638,6 +1638,7 @@ bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node)
             {
                 outputTriplet(visit, "", "[", "]");
             }
+        }
         break;
       case EOpIndexIndirect:
         // We do not currently support indirect references to interface blocks
@@ -1645,10 +1646,23 @@ bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node)
         outputTriplet(visit, "", "[", "]");
         break;
       case EOpIndexDirectStruct:
+        if (visit == InVisit)
+        {
+            const TStructure* structure = node->getLeft()->getType().getStruct();
+            const TIntermConstantUnion* index = node->getRight()->getAsConstantUnion();
+            const TField* field = structure->fields()[index->getIConst(0)];
+            out << "." + decorateField(field->name(), *structure);
+
+            return false;
+        }
+        break;
       case EOpIndexDirectInterfaceBlock:
         if (visit == InVisit)
         {
-            out << "." + decorateField(node->getType().getFieldName(), node->getLeft()->getType());
+            const TInterfaceBlock* interfaceBlock = node->getLeft()->getType().getInterfaceBlock();
+            const TIntermConstantUnion* index = node->getRight()->getAsConstantUnion();
+            const TField* field = interfaceBlock->fields()[index->getIConst(0)];
+            out << "." + decorate(field->name());
 
             return false;
         }
@@ -1717,18 +1731,19 @@ bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node)
                 out << "!(";
             }
 
-            const TTypeList *fields = node->getLeft()->getType().getStruct();
+            const TStructure &structure = *node->getLeft()->getType().getStruct();
+            const TFieldList &fields = structure.fields();
 
-            for (size_t i = 0; i < fields->size(); i++)
+            for (size_t i = 0; i < fields.size(); i++)
             {
-                const TType *fieldType = (*fields)[i].type;
+                const TField *field = fields[i];
 
                 node->getLeft()->traverse(this);
-                out << "." + decorateField(fieldType->getFieldName(), node->getLeft()->getType()) + " == ";
+                out << "." + decorateField(field->name(), structure) + " == ";
                 node->getRight()->traverse(this);
-                out << "." + decorateField(fieldType->getFieldName(), node->getLeft()->getType());
+                out << "." + decorateField(field->name(), structure);
 
-                if (i < fields->size() - 1)
+                if (i < fields.size() - 1)
                 {
                     out << " && ";
                 }
@@ -1996,7 +2011,7 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
             {
                 if (variable->getType().getStruct())
                 {
-                    addConstructor(variable->getType(), scopedStruct(variable->getType().getTypeName()), NULL);
+                    addConstructor(variable->getType(), scopedStruct(variable->getType().getStruct()->name()), NULL);
                 }
 
                 if (!variable->getAsSymbolNode() || variable->getAsSymbolNode()->getSymbol() != "")   // Variable declaration
@@ -2123,7 +2138,7 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
                 {
                     if (symbol->getType().getStruct())
                     {
-                        addConstructor(symbol->getType(), scopedStruct(symbol->getType().getTypeName()), NULL);
+                        addConstructor(symbol->getType(), scopedStruct(symbol->getType().getStruct()->name()), NULL);
                     }
 
                     out << argumentString(symbol);
@@ -2319,8 +2334,8 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
         outputTriplet(visit, "mat4(", ", ", ")");
         break;
       case EOpConstructStruct:
-        addConstructor(node->getType(), scopedStruct(node->getType().getTypeName()), &node->getSequence());
-        outputTriplet(visit, structLookup(node->getType().getTypeName()) + "_ctor(", ", ", ")");
+        addConstructor(node->getType(), scopedStruct(node->getType().getStruct()->name()), &node->getSequence());
+        outputTriplet(visit, structLookup(node->getType().getStruct()->name()) + "_ctor(", ", ", ")");
         break;
       case EOpLessThan:         outputTriplet(visit, "(", " < ", ")");                 break;
       case EOpGreaterThan:      outputTriplet(visit, "(", " > ", ")");                 break;
@@ -2910,15 +2925,17 @@ TString OutputHLSL::qualifierString(TQualifier qualifier)
 
 TString OutputHLSL::typeString(const TType &type)
 {
-    if (type.getBasicType() == EbtStruct)
+    const TStructure* structure = type.getStruct();
+    if (structure)
     {
-        if (type.getTypeName() != "")
+        const TString& typeName = structure->name();
+        if (typeName != "")
         {
-            return structLookup(type.getTypeName());
+            return structLookup(typeName);
         }
         else   // Nameless structure, define in place
         {
-            return structureString(type, false, false);
+            return structureString(*structure, false, false);
         }
     }
     else if (type.isMatrix())
@@ -3038,42 +3055,41 @@ TString OutputHLSL::initializer(const TType &type)
     return "{" + string + "}";
 }
 
-TString OutputHLSL::structureString(const TType &structType, bool useHLSLRowMajorPacking, bool useStd140Packing)
+TString OutputHLSL::structureString(const TStructure &structure, bool useHLSLRowMajorPacking, bool useStd140Packing)
 {
-    ASSERT(structType.getStruct());
-
-    const TTypeList &fields = *structType.getStruct();
-    const bool isNameless = (structType.getTypeName() == "");
-    const TString &structName = structureTypeName(structType, useHLSLRowMajorPacking, useStd140Packing);
-
+    const TFieldList &fields = structure.fields();
+    const bool isNameless = (structure.name() == "");
+    const TString &structName = structureTypeName(structure, useHLSLRowMajorPacking, useStd140Packing);
     const TString declareString = (isNameless ? "struct" : "struct " + structName);
 
-    TString structure;
-    structure += declareString + "\n"
+    TString string;
+    string += declareString + "\n"
               "{\n";
 
     int elementIndex = 0;
 
     for (unsigned int i = 0; i < fields.size(); i++)
     {
-        const TType &field = *fields[i].type;
+        const TField &field = *fields[i];
+        const TType &fieldType = *field.type();
+        const TStructure *fieldStruct = fieldType.getStruct();
+        const TString &fieldTypeString = fieldStruct ? structureTypeName(*fieldStruct, useHLSLRowMajorPacking, useStd140Packing) : typeString(fieldType);
 
         if (useStd140Packing)
         {
-            structure += std140PrePaddingString(field, &elementIndex);
+            string += std140PrePaddingString(*field.type(), &elementIndex);
         }
 
-        structure += "    " + structureTypeName(field, useHLSLRowMajorPacking, useStd140Packing) + " " +
-                     decorateField(field.getFieldName(), structType) + arrayString(field) + ";\n";
+        string += "    " + fieldTypeString + " " + decorateField(field.name(), structure) + arrayString(fieldType) + ";\n";
 
         if (useStd140Packing)
         {
-            structure += std140PostPaddingString(field, useHLSLRowMajorPacking);
+            string += std140PostPaddingString(*field.type(), useHLSLRowMajorPacking);
         }
     }
 
     // Nameless structs do not finish with a semicolon and newline, to leave room for an instance variable
-    structure += (isNameless ? "} " : "};\n");
+    string += (isNameless ? "} " : "};\n");
 
     // Add remaining element index to the global map, for use with nested structs in standard layouts
     if (useStd140Packing)
@@ -3081,17 +3097,12 @@ TString OutputHLSL::structureString(const TType &structType, bool useHLSLRowMajo
         mStd140StructElementIndexes[structName] = elementIndex;
     }
 
-    return structure;
+    return string;
 }
 
-TString OutputHLSL::structureTypeName(const TType &structType, bool useHLSLRowMajorPacking, bool useStd140Packing)
+TString OutputHLSL::structureTypeName(const TStructure &structure, bool useHLSLRowMajorPacking, bool useStd140Packing)
 {
-    if (structType.getBasicType() != EbtStruct)
-    {
-        return typeString(structType);
-    }
-
-    if (structType.getTypeName() == "")
+    if (structure.name() == "")
     {
         return "";
     }
@@ -3112,7 +3123,7 @@ TString OutputHLSL::structureTypeName(const TType &structType, bool useHLSLRowMa
         prefix += "rm";
     }
 
-    return prefix + typeString(structType);
+    return prefix + structLookup(structure.name());
 }
 
 void OutputHLSL::addConstructor(const TType &type, const TString &name, const TIntermSequence *parameters)
@@ -3137,37 +3148,38 @@ void OutputHLSL::addConstructor(const TType &type, const TString &name, const TI
     typedef std::vector<TType> ParameterArray;
     ParameterArray ctorParameters;
 
-    if (type.getStruct())
+    const TStructure* structure = type.getStruct();
+    if (structure)
     {
         mStructNames.insert(decorate(name));
 
-        const TString &structure = structureString(type, false, false);
+        const TString &structString = structureString(*structure, false, false);
 
-        if (std::find(mStructDeclarations.begin(), mStructDeclarations.end(), structure) == mStructDeclarations.end())
+        if (std::find(mStructDeclarations.begin(), mStructDeclarations.end(), structString) == mStructDeclarations.end())
         {
             // Add row-major packed struct for interface blocks
             TString rowMajorString = "#pragma pack_matrix(row_major)\n" +
-                                     structureString(type, true, false) +
+                                     structureString(*structure, true, false) +
                                      "#pragma pack_matrix(column_major)\n";
 
             const TString &std140Prefix = "std";
-            TString std140String = structureString(type, false, true);
+            TString std140String = structureString(*structure, false, true);
 
             const TString &std140RowMajorPrefix = "std_rm";
             TString std140RowMajorString = "#pragma pack_matrix(row_major)\n" +
-                                           structureString(type, true, true) +
+                                           structureString(*structure, true, true) +
                                            "#pragma pack_matrix(column_major)\n";
 
-            mStructDeclarations.push_back(structure);
+            mStructDeclarations.push_back(structString);
             mStructDeclarations.push_back(rowMajorString);
             mStructDeclarations.push_back(std140String);
             mStructDeclarations.push_back(std140RowMajorString);
         }
 
-        const TTypeList &fields = *type.getStruct();
+        const TFieldList &fields = structure->fields();
         for (unsigned int i = 0; i < fields.size(); i++)
         {
-            ctorParameters.push_back(*fields[i].type);
+            ctorParameters.push_back(*fields[i]->type());
         }
     }
     else if (parameters)
@@ -3338,19 +3350,20 @@ const ConstantUnion *OutputHLSL::writeConstantUnion(const TType &type, const Con
 {
     TInfoSinkBase &out = mBody;
 
-    if (type.getBasicType() == EbtStruct)
+    const TStructure* structure = type.getStruct();
+    if (structure)
     {
-        out << structLookup(type.getTypeName()) + "_ctor(";
+        out << structLookup(structure->name()) + "_ctor(";
         
-        const TTypeList *structure = type.getStruct();
+        const TFieldList& fields = structure->fields();
 
-        for (size_t i = 0; i < structure->size(); i++)
+        for (size_t i = 0; i < fields.size(); i++)
         {
-            const TType *fieldType = (*structure)[i].type;
+            const TType *fieldType = fields[i]->type();
 
             constUnion = writeConstantUnion(*fieldType, constUnion);
 
-            if (i != structure->size() - 1)
+            if (i != fields.size() - 1)
             {
                 out << ", ";
             }
@@ -3456,9 +3469,9 @@ TString OutputHLSL::decorateUniform(const TString &string, const TType &type)
     return decorate(string);
 }
 
-TString OutputHLSL::decorateField(const TString &string, const TType &structure)
+TString OutputHLSL::decorateField(const TString &string, const TStructure &structure)
 {
-    if (structure.getTypeName().compare(0, 3, "gl_") != 0)
+    if (structure.name().compare(0, 3, "gl_") != 0)
     {
         return decorate(string);
     }
@@ -3504,31 +3517,32 @@ int OutputHLSL::uniformRegister(TIntermSymbol *uniform)
     return index;
 }
 
-void OutputHLSL::declareUniformToList(const TType &type, const TString &name, int index, ActiveUniforms& output)
+void OutputHLSL::declareUniformToList(const TType &type, const TString &name, int registerIndex, ActiveUniforms& output)
 {
-    const TTypeList *structure = type.getStruct();
+    const TStructure *structure = type.getStruct();
 
     if (!structure)
     {
         const bool isRowMajorMatrix = (type.isMatrix() && type.getLayoutQualifier().matrixPacking == EmpRowMajor);
-        output.push_back(Uniform(glVariableType(type), glVariablePrecision(type), name.c_str(), (unsigned int)type.getArraySize(), (unsigned int)index, isRowMajorMatrix));
+        output.push_back(Uniform(glVariableType(type), glVariablePrecision(type), name.c_str(), (unsigned int)type.getArraySize(), (unsigned int)registerIndex, isRowMajorMatrix));
     }
     else
     {
-        Uniform structUniform(GL_NONE, GL_NONE, name.c_str(), (unsigned int)type.getArraySize(), (unsigned int)index, false);
+        Uniform structUniform(GL_NONE, GL_NONE, name.c_str(), (unsigned int)type.getArraySize(), (unsigned int)registerIndex, false);
 
-        int fieldIndex = index;
+        int fieldRegister = registerIndex;
+        const TFieldList &fields = structure->fields();
 
-        for (size_t i = 0; i < structure->size(); i++)
+        for (size_t fieldIndex = 0; fieldIndex < fields.size(); fieldIndex++)
         {
-            TType fieldType = *(*structure)[i].type;
-            const TString &fieldName = fieldType.getFieldName();
+            TField *field = fields[fieldIndex];
+            TType *fieldType = field->type();
 
             // make sure to copy matrix packing information
-            fieldType.setLayoutQualifier(type.getLayoutQualifier());
+            fieldType->setLayoutQualifier(type.getLayoutQualifier());
 
-            declareUniformToList(fieldType, fieldName, fieldIndex, structUniform.fields);
-            fieldIndex += fieldType.totalRegisterCount();
+            declareUniformToList(*fieldType, field->name(), fieldRegister, structUniform.fields);
+            fieldRegister += fieldType->totalRegisterCount();
         }
 
         output.push_back(structUniform);

src/compiler/OutputHLSL.h

@@ -40,14 +40,14 @@ class OutputHLSL : public TIntermTraverser
     TString typeString(const TType &type);
     TString textureString(const TType &type);
     TString interpolationString(TQualifier qualifier);
-    TString structureString(const TType &structType, bool useHLSLRowMajorPacking, bool useStd140Packing);
-    TString structureTypeName(const TType &structType, bool useHLSLRowMajorPacking, bool useStd140Packing);
+    TString structureString(const TStructure &structure, bool useHLSLRowMajorPacking, bool useStd140Packing);
+    TString structureTypeName(const TStructure &structure, bool useHLSLRowMajorPacking, bool useStd140Packing);
     static TString qualifierString(TQualifier qualifier);
     static TString arrayString(const TType &type);
     static TString initializer(const TType &type);
     static TString decorate(const TString &string);                      // Prepends an underscore to avoid naming clashes
     static TString decorateUniform(const TString &string, const TType &type);
-    static TString decorateField(const TString &string, const TType &structure);
+    static TString decorateField(const TString &string, const TStructure &structure);
 
   protected:
     void header();
@@ -187,20 +187,20 @@ class OutputHLSL : public TIntermTraverser
     TString registerString(TIntermSymbol *operand);
     int samplerRegister(TIntermSymbol *sampler);
     int uniformRegister(TIntermSymbol *uniform);
-    void declareUniformToList(const TType &type, const TString &name, int index, ActiveUniforms& output);
+    void declareUniformToList(const TType &type, const TString &name, int registerIndex, ActiveUniforms& output);
     void declareUniform(const TType &type, const TString &name, int index);
 
-    TString interfaceBlockUniformName(const TType &interfaceBlockType, const TType &uniformType);
+    TString interfaceBlockFieldString(const TInterfaceBlock &interfaceBlock, const TField &field);
     TString decoratePrivate(const TString &privateText);
-    TString interfaceBlockStructName(const TType &interfaceBlockType);
-    TString interfaceBlockInstanceString(const TType& interfaceBlockType, unsigned int arrayIndex);
-    TString interfaceBlockMemberTypeString(const TType &memberType, TLayoutBlockStorage blockStorage);
-    TString interfaceBlockMemberString(const TTypeList &typeList, TLayoutBlockStorage blockStorage);
-    TString interfaceBlockStructString(const TType &interfaceBlockType);
-    TString interfaceBlockString(const TType &interfaceBlockType, unsigned int registerIndex, unsigned int arrayIndex);
+    TString interfaceBlockStructNameString(const TInterfaceBlock &interfaceBlockType);
+    TString interfaceBlockInstanceString(const TInterfaceBlock& interfaceBlock, unsigned int arrayIndex);
+    TString interfaceBlockFieldTypeString(const TField &field, TLayoutBlockStorage blockStorage);
+    TString interfaceBlockFieldString(const TInterfaceBlock &interfaceBlock, TLayoutBlockStorage blockStorage);
+    TString interfaceBlockStructString(const TInterfaceBlock &interfaceBlock);
+    TString interfaceBlockString(const TInterfaceBlock &interfaceBlock, unsigned int registerIndex, unsigned int arrayIndex);
     TString std140PrePaddingString(const TType &type, int *elementIndex);
     TString std140PostPaddingString(const TType &type, bool useHLSLRowMajorPacking);
-    TString structInitializerString(int indent, const TTypeList &structMembers, const TString &structName);
+    TString structInitializerString(int indent, const TStructure &structure, const TString &rhsStructName);
     
     static GLenum glVariableType(const TType &type);
     static GLenum glVariablePrecision(const TType &type);

src/compiler/ParseHelper.cpp

@@ -532,7 +532,7 @@ bool TParseContext::constructorErrorCheck(const TSourceLoc& line, TIntermNode* n
         return true;
     }
     
-    if (op == EOpConstructStruct && !type->isArray() && int(type->getStruct()->size()) != function.getParamCount()) {
+    if (op == EOpConstructStruct && !type->isArray() && int(type->getStruct()->fields().size()) != function.getParamCount()) {
         error(line, "Number of constructor parameters does not match the number of structure fields", "constructor");
         return true;
     }
@@ -672,10 +672,10 @@ bool TParseContext::containsSampler(TType& type)
     if (IsSampler(type.getBasicType()))
         return true;
 
-    if (type.getBasicType() == EbtStruct || type.getBasicType() == EbtInterfaceBlock) {
-        TTypeList& structure = *type.getStruct();
-        for (unsigned int i = 0; i < structure.size(); ++i) {
-            if (containsSampler(*structure[i].type))
+    if (type.getBasicType() == EbtStruct || type.isInterfaceBlock()) {
+        const TFieldList& fields = type.getStruct()->fields();
+        for (unsigned int i = 0; i < fields.size(); ++i) {
+            if (containsSampler(*fields[i]->type()))
                 return true;
         }
     }
@@ -1503,9 +1503,9 @@ TIntermTyped* TParseContext::addConstructor(TIntermNode* node, const TType* type
 
     TIntermAggregate* aggrNode = node->getAsAggregate();
     
-    TTypeList::const_iterator memberTypes;
+    TFieldList::const_iterator memberTypes;
     if (op == EOpConstructStruct)
-        memberTypes = type->getStruct()->begin();
+        memberTypes = type->getStruct()->fields().begin();
     
     TType elementType = *type;
     if (type->isArray())
@@ -1527,7 +1527,7 @@ TIntermTyped* TParseContext::addConstructor(TIntermNode* node, const TType* type
         if (type->isArray())
             newNode = constructStruct(node, &elementType, 1, node->getLine(), false);
         else if (op == EOpConstructStruct)
-            newNode = constructStruct(node, (*memberTypes).type, 1, node->getLine(), false);
+            newNode = constructStruct(node, (*memberTypes)->type(), 1, node->getLine(), false);
         else
             newNode = constructBuiltIn(type, op, node, node->getLine(), false);
 
@@ -1558,7 +1558,7 @@ TIntermTyped* TParseContext::addConstructor(TIntermNode* node, const TType* type
         if (type->isArray())
             newNode = constructStruct(*p, &elementType, paramCount+1, node->getLine(), true);
         else if (op == EOpConstructStruct)
-            newNode = constructStruct(*p, (memberTypes[paramCount]).type, paramCount+1, node->getLine(), true);
+            newNode = constructStruct(*p, (memberTypes[paramCount])->type(), paramCount+1, node->getLine(), true);
         else
             newNode = constructBuiltIn(type, op, *p, node->getLine(), true);
         
@@ -1817,14 +1817,14 @@ TIntermTyped* TParseContext::addConstArrayNode(int index, TIntermTyped* node, co
 //
 TIntermTyped* TParseContext::addConstStruct(const TString &identifier, TIntermTyped *node, const TSourceLoc& line)
 {
-    const TTypeList* fields = node->getType().getStruct();
+    const TFieldList& fields = node->getType().getStruct()->fields();
     size_t instanceSize = 0;
 
-    for (size_t index = 0; index < fields->size(); ++index) {
-        if ((*fields)[index].type->getFieldName() == identifier) {
+    for (size_t index = 0; index < fields.size(); ++index) {
+        if (fields[index]->name() == identifier) {
             break;
         } else {
-            instanceSize += (*fields)[index].type->getObjectSize();
+            instanceSize += fields[index]->type()->getObjectSize();
         }
     }
 
@@ -1847,8 +1847,8 @@ TIntermTyped* TParseContext::addConstStruct(const TString &identifier, TIntermTy
 //
 // Interface/uniform blocks
 //
-TIntermAggregate* TParseContext::addInterfaceBlock(const TPublicType& typeQualifier, const TSourceLoc& nameLine, const TString& blockName, TTypeList* typeList, 
-                                                   const TString& instanceName, const TSourceLoc& instanceLine, TIntermTyped* arrayIndex, const TSourceLoc& arrayIndexLine)
+TIntermAggregate* TParseContext::addInterfaceBlock(const TPublicType& typeQualifier, const TSourceLoc& nameLine, const TString& blockName, TFieldList* fieldList, 
+                                                   const TString* instanceName, const TSourceLoc& instanceLine, TIntermTyped* arrayIndex, const TSourceLoc& arrayIndexLine)
 {
     if (reservedErrorCheck(nameLine, blockName))
         recover();
@@ -1881,94 +1881,95 @@ TIntermAggregate* TParseContext::addInterfaceBlock(const TPublicType& typeQualif
         recover();
     }
 
-    // check for sampler types
-    for (size_t memberIndex = 0; memberIndex < typeList->size(); ++memberIndex) {
-        const TTypeLine& memberTypeLine = (*typeList)[memberIndex];
-        TType* memberType = memberTypeLine.type;
-        if (IsSampler(memberType->getBasicType())) {
-            error(memberTypeLine.line, "unsupported type", memberType->getBasicString(), "sampler types are not allowed in interface blocks");
+    // check for sampler types and apply layout qualifiers
+    for (size_t memberIndex = 0; memberIndex < fieldList->size(); ++memberIndex) {
+        TField* field = (*fieldList)[memberIndex];
+        TType* fieldType = field->type();
+        if (IsSampler(fieldType->getBasicType())) {
+            error(field->line(), "unsupported type", fieldType->getBasicString(), "sampler types are not allowed in interface blocks");
             recover();
         }
 
-        const TQualifier qualifier = memberTypeLine.type->getQualifier();
+        const TQualifier qualifier = fieldType->getQualifier();
         switch (qualifier)
         {
           case EvqGlobal:
           case EvqUniform:
             break;
           default:
-            error(memberTypeLine.line, "invalid qualifier on interface block member", getQualifierString(qualifier));
+            error(field->line(), "invalid qualifier on interface block member", getQualifierString(qualifier));
             recover();
             break;
         }
 
         // check layout qualifiers
-        TLayoutQualifier memberLayoutQualifier = memberType->getLayoutQualifier();
-        if (layoutLocationErrorCheck(memberTypeLine.line, memberLayoutQualifier))
+        TLayoutQualifier fieldLayoutQualifier = fieldType->getLayoutQualifier();
+        if (layoutLocationErrorCheck(field->line(), fieldLayoutQualifier))
         {
             recover();
         }
 
-        if (memberLayoutQualifier.blockStorage != EbsUnspecified)
+        if (fieldLayoutQualifier.blockStorage != EbsUnspecified)
         {
-            error(memberTypeLine.line, "invalid layout qualifier:", getBlockStorageString(memberLayoutQualifier.blockStorage), "cannot be used here");
+            error(field->line(), "invalid layout qualifier:", getBlockStorageString(fieldLayoutQualifier.blockStorage), "cannot be used here");
             recover();
         }
 
-        if (memberLayoutQualifier.matrixPacking == EmpUnspecified)
+        if (fieldLayoutQualifier.matrixPacking == EmpUnspecified)
         {
-            memberLayoutQualifier.matrixPacking = blockLayoutQualifier.matrixPacking;
+            fieldLayoutQualifier.matrixPacking = blockLayoutQualifier.matrixPacking;
         }
-        else if (!memberType->isMatrix())
+        else if (!fieldType->isMatrix())
         {
-            error(memberTypeLine.line, "invalid layout qualifier:", getMatrixPackingString(memberLayoutQualifier.matrixPacking), "can only be used on matrix types");
+            error(field->line(), "invalid layout qualifier:", getMatrixPackingString(fieldLayoutQualifier.matrixPacking), "can only be used on matrix types");
             recover();
         }
 
-        memberType->setLayoutQualifier(memberLayoutQualifier);
+        fieldType->setLayoutQualifier(fieldLayoutQualifier);
     }
 
-    TType* interfaceBlock = new TType(typeList, blockName);
-    interfaceBlock->setBasicType(EbtInterfaceBlock);
-    interfaceBlock->setQualifier(typeQualifier.qualifier);
-    interfaceBlock->setLayoutQualifier(blockLayoutQualifier);
+    // add array index
+    int arraySize = 0;
+    if (arrayIndex != NULL)
+    {
+        if (arraySizeErrorCheck(arrayIndexLine, arrayIndex, arraySize))
+            recover();
+    }
+
+    TInterfaceBlock* interfaceBlock = new TInterfaceBlock(&blockName, fieldList, instanceName, arraySize, blockLayoutQualifier);
+    TType interfaceBlockType(interfaceBlock, typeQualifier.qualifier, blockLayoutQualifier, arraySize);
 
     TString symbolName = "";
     int symbolId = 0;
 
-    if (instanceName == "")
+    if (!instanceName)
     {
         // define symbols for the members of the interface block
-        for (size_t memberIndex = 0; memberIndex < typeList->size(); ++memberIndex) {
-            const TTypeLine& memberTypeLine = (*typeList)[memberIndex];
-            TType* memberType = memberTypeLine.type;
-            memberType->setInterfaceBlockType(interfaceBlock);
-            TVariable* memberVariable = new TVariable(&memberType->getFieldName(), *memberType);
-            memberVariable->setQualifier(typeQualifier.qualifier);
-            if (!symbolTable.declare(*memberVariable)) {
-                error(memberTypeLine.line, "redefinition", memberType->getFieldName().c_str(), "interface block member name");
+        for (size_t memberIndex = 0; memberIndex < fieldList->size(); ++memberIndex)
+        {
+            TField* field = (*fieldList)[memberIndex];
+            TType* fieldType = field->type();
+
+            // set parent pointer of the field variable
+            fieldType->setInterfaceBlock(interfaceBlock);
+
+            TVariable* fieldVariable = new TVariable(&field->name(), *fieldType);
+            fieldVariable->setQualifier(typeQualifier.qualifier);
+
+            if (!symbolTable.declare(*fieldVariable)) {
+                error(field->line(), "redefinition", field->name().c_str(), "interface block member name");
                 recover();
             }
         }
     }
     else
     {
-        interfaceBlock->setInstanceName(instanceName);
-
-        // add array index
-        if (arrayIndex != NULL)
-        {
-            int size;
-            if (arraySizeErrorCheck(arrayIndexLine, arrayIndex, size))
-                recover();
-            interfaceBlock->setArraySize(size);
-        }
-
         // add a symbol for this interface block
-        TVariable* instanceTypeDef = new TVariable(&instanceName, *interfaceBlock, false);
+        TVariable* instanceTypeDef = new TVariable(instanceName, interfaceBlockType, false);
         instanceTypeDef->setQualifier(typeQualifier.qualifier);
+
         if (!symbolTable.declare(*instanceTypeDef)) {
-            error(instanceLine, "redefinition", instanceName.c_str(), "interface block instance name");
+            error(instanceLine, "redefinition", instanceName->c_str(), "interface block instance name");
             recover();
         }
 
@@ -1976,9 +1977,10 @@ TIntermAggregate* TParseContext::addInterfaceBlock(const TPublicType& typeQualif
         symbolName = instanceTypeDef->getName();
     }
 
-    exitStructDeclaration();
-    TIntermAggregate *aggregate = intermediate.makeAggregate(intermediate.addSymbol(symbolId, symbolName, *interfaceBlock, typeQualifier.line), nameLine);
+    TIntermAggregate *aggregate = intermediate.makeAggregate(intermediate.addSymbol(symbolId, symbolName, interfaceBlockType, typeQualifier.line), nameLine);
     aggregate->setOp(EOpDeclaration);
+
+    exitStructDeclaration();
     return aggregate;
 }
 
@@ -2008,21 +2010,21 @@ const int kWebGLMaxStructNesting = 4;
 
 }  // namespace
 
-bool TParseContext::structNestingErrorCheck(const TSourceLoc& line, const TType& fieldType)
+bool TParseContext::structNestingErrorCheck(const TSourceLoc& line, const TField& field)
 {
     if (!isWebGLBasedSpec(shaderSpec)) {
         return false;
     }
 
-    if (fieldType.getBasicType() != EbtStruct) {
+    if (field.type()->getBasicType() != EbtStruct) {
         return false;
     }
 
     // We're already inside a structure definition at this point, so add
     // one to the field's struct nesting.
-    if (1 + fieldType.getDeepestStructNesting() > kWebGLMaxStructNesting) {
+    if (1 + field.type()->getDeepestStructNesting() > kWebGLMaxStructNesting) {
         std::stringstream extraInfoStream;
-        extraInfoStream << "Reference of struct type " << fieldType.getTypeName() 
+        extraInfoStream << "Reference of struct type " << field.type()->getStruct()->name() 
                         << " exceeds maximum struct nesting of " << kWebGLMaxStructNesting;
         std::string extraInfo = extraInfoStream.str();
         error(line, "", "", extraInfo.c_str());
@@ -2115,7 +2117,7 @@ TIntermTyped* TParseContext::addIndexExpression(TIntermTyped *baseExpression, co
     }
     else
     {
-        if (baseExpression->getBasicType() == EbtInterfaceBlock)
+        if (baseExpression->isInterfaceBlock())
         {
             error(location, "", "[", "array indexes for interface blocks arrays must be constant integeral expressions");
             recover();
@@ -2137,10 +2139,15 @@ TIntermTyped* TParseContext::addIndexExpression(TIntermTyped *baseExpression, co
     }
     else if (baseExpression->isArray())
     {
-        if (baseExpression->getType().getStruct())
+        const TType &baseType = baseExpression->getType();
+        if (baseType.getStruct())
+        {
+            TType copyOfType(baseType.getStruct());
+            indexedExpression->setType(copyOfType);
+        }
+        else if (baseType.isInterfaceBlock())
         {
-            TType copyOfType(baseExpression->getType().getStruct(), baseExpression->getType().getTypeName());
-            copyOfType.setBasicType(baseExpression->getType().getBasicType()); // necessary to preserve interface block basic type
+            TType copyOfType(baseType.getInterfaceBlock(), baseType.getQualifier(), baseType.getLayoutQualifier(), 0);
             indexedExpression->setType(copyOfType);
         }
         else
@@ -2247,8 +2254,8 @@ TIntermTyped* TParseContext::addFieldSelectionExpression(TIntermTyped *baseExpre
     else if (baseExpression->getBasicType() == EbtStruct)
     {
         bool fieldFound = false;
-        const TTypeList* fields = baseExpression->getType().getStruct();
-        if (fields == 0)
+        const TFieldList& fields = baseExpression->getType().getStruct()->fields();
+        if (fields.empty())
         {
             error(dotLocation, "structure has no fields", "Internal Error");
             recover();
@@ -2257,9 +2264,9 @@ TIntermTyped* TParseContext::addFieldSelectionExpression(TIntermTyped *baseExpre
         else
         {
             unsigned int i;
-            for (i = 0; i < fields->size(); ++i)
+            for (i = 0; i < fields.size(); ++i)
             {
-                if ((*fields)[i].type->getFieldName() == fieldString)
+                if (fields[i]->name() == fieldString)
                 {
                     fieldFound = true;
                     break;
@@ -2277,7 +2284,7 @@ TIntermTyped* TParseContext::addFieldSelectionExpression(TIntermTyped *baseExpre
                     }
                     else
                     {
-                        indexedExpression->setType(*(*fields)[i].type);
+                        indexedExpression->setType(*fields[i]->type());
                         // change the qualifier of the return type, not of the structure field
                         // as the structure definition is shared between various structures.
                         indexedExpression->getTypePointer()->setQualifier(EvqConst);
@@ -2287,9 +2294,9 @@ TIntermTyped* TParseContext::addFieldSelectionExpression(TIntermTyped *baseExpre
                 {
                     ConstantUnion *unionArray = new ConstantUnion[1];
                     unionArray->setIConst(i);
-                    TIntermTyped* index = intermediate.addConstantUnion(unionArray, *(*fields)[i].type, fieldLocation);
+                    TIntermTyped* index = intermediate.addConstantUnion(unionArray, *fields[i]->type(), fieldLocation);
                     indexedExpression = intermediate.addIndex(EOpIndexDirectStruct, baseExpression, index, dotLocation);
-                    indexedExpression->setType(*(*fields)[i].type);
+                    indexedExpression->setType(*fields[i]->type());
                 }
             }
             else
@@ -2300,11 +2307,11 @@ TIntermTyped* TParseContext::addFieldSelectionExpression(TIntermTyped *baseExpre
             }
         }
     }
-    else if (baseExpression->getBasicType() == EbtInterfaceBlock)
+    else if (baseExpression->isInterfaceBlock())
     {
         bool fieldFound = false;
-        const TTypeList* fields = baseExpression->getType().getStruct();
-        if (fields == 0)
+        const TFieldList& fields = baseExpression->getType().getInterfaceBlock()->fields();
+        if (fields.empty())
         {
             error(dotLocation, "interface block has no fields", "Internal Error");
             recover();
@@ -2313,9 +2320,9 @@ TIntermTyped* TParseContext::addFieldSelectionExpression(TIntermTyped *baseExpre
         else
         {
             unsigned int i;
-            for (i = 0; i < fields->size(); ++i)
+            for (i = 0; i < fields.size(); ++i)
             {
-                if ((*fields)[i].type->getFieldName() == fieldString)
+                if (fields[i]->name() == fieldString)
                 {
                     fieldFound = true;
                     break;
@@ -2325,9 +2332,9 @@ TIntermTyped* TParseContext::addFieldSelectionExpression(TIntermTyped *baseExpre
             {
                 ConstantUnion *unionArray = new ConstantUnion[1];
                 unionArray->setIConst(i);
-                TIntermTyped* index = intermediate.addConstantUnion(unionArray, *(*fields)[i].type, fieldLocation);
+                TIntermTyped* index = intermediate.addConstantUnion(unionArray, *fields[i]->type(), fieldLocation);
                 indexedExpression = intermediate.addIndex(EOpIndexDirectInterfaceBlock, baseExpression, index, dotLocation);
-                indexedExpression->setType(*(*fields)[i].type);
+                indexedExpression->setType(*fields[i]->type());
             }
             else
             {
@@ -2446,17 +2453,17 @@ TLayoutQualifier TParseContext::joinLayoutQualifiers(TLayoutQualifier leftQualif
     return joinedQualifier;
 }
 
-TTypeList *TParseContext::addStructDeclaratorList(const TPublicType& typeSpecifier, TTypeList *typeList)
+TFieldList *TParseContext::addStructDeclaratorList(const TPublicType& typeSpecifier, TFieldList *fieldList)
 {
-    if (voidErrorCheck(typeSpecifier.line, (*typeList)[0].type->getFieldName(), typeSpecifier)) {
+    if (voidErrorCheck(typeSpecifier.line, (*fieldList)[0]->name(), typeSpecifier)) {
         recover();
     }
 
-    for (unsigned int i = 0; i < typeList->size(); ++i) {
+    for (unsigned int i = 0; i < fieldList->size(); ++i) {
         //
         // Careful not to replace already known aspects of type, like array-ness
         //
-        TType* type = (*typeList)[i].type;
+        TType* type = (*fieldList)[i]->type();
         type->setBasicType(typeSpecifier.type);
         type->setPrimarySize(typeSpecifier.primarySize);
         type->setSecondarySize(typeSpecifier.secondarySize);
@@ -2473,46 +2480,46 @@ TTypeList *TParseContext::addStructDeclaratorList(const TPublicType& typeSpecifi
             type->setArraySize(typeSpecifier.arraySize);
         if (typeSpecifier.userDef) {
             type->setStruct(typeSpecifier.userDef->getStruct());
-            type->setTypeName(typeSpecifier.userDef->getTypeName());
         }
 
-        if (structNestingErrorCheck(typeSpecifier.line, *type)) {
+        if (structNestingErrorCheck(typeSpecifier.line, *(*fieldList)[i])) {
             recover();
         }
     }
 
-    return typeList;
+    return fieldList;
 }
 
-TPublicType TParseContext::addStructure(const TSourceLoc& structLine, const TSourceLoc& nameLine, const TString &structName, TTypeList* typeList)
+TPublicType TParseContext::addStructure(const TSourceLoc& structLine, const TSourceLoc& nameLine, const TString *structName, TFieldList* fieldList)
 {
-    TType* structure = new TType(typeList, structName);
+    TStructure* structure = new TStructure(structName, fieldList);
+    TType* structureType = new TType(structure);
 
-    if (!structName.empty())
+    if (!structName->empty())
     {
-        if (reservedErrorCheck(nameLine, structName))
+        if (reservedErrorCheck(nameLine, *structName))
         {
             recover();
         }
-        TVariable* userTypeDef = new TVariable(&structName, *structure, true);
+        TVariable* userTypeDef = new TVariable(structName, *structureType, true);
         if (!symbolTable.declare(*userTypeDef)) {
-            error(nameLine, "redefinition", structName.c_str(), "struct");
+            error(nameLine, "redefinition", structName->c_str(), "struct");
             recover();
         }
     }
 
     // ensure we do not specify any storage qualifiers on the struct members
-    for (unsigned int typeListIndex = 0; typeListIndex < typeList->size(); typeListIndex++)
+    for (unsigned int typeListIndex = 0; typeListIndex < fieldList->size(); typeListIndex++)
     {
-        const TTypeLine &typeLine = (*typeList)[typeListIndex];
-        const TQualifier qualifier = typeLine.type->getQualifier();
+        const TField &field = *(*fieldList)[typeListIndex];
+        const TQualifier qualifier = field.type()->getQualifier();
         switch (qualifier)
         {
           case EvqGlobal:
           case EvqTemporary:
             break;
           default:
-            error(typeLine.line, "invalid qualifier on struct member", getQualifierString(qualifier));
+            error(field.line(), "invalid qualifier on struct member", getQualifierString(qualifier));
             recover();
             break;
         }
@@ -2520,7 +2527,7 @@ TPublicType TParseContext::addStructure(const TSourceLoc& structLine, const TSou
 
     TPublicType publicType;
     publicType.setBasic(EbtStruct, EvqTemporary, structLine);
-    publicType.userDef = structure;
+    publicType.userDef = structureType;
     exitStructDeclaration();
 
     return publicType;

src/compiler/ParseHelper.h

@@ -142,11 +142,11 @@ struct TParseContext {
     TIntermTyped* addIndexExpression(TIntermTyped *baseExpression, const TSourceLoc& location, TIntermTyped *indexExpression);
     TIntermTyped* addFieldSelectionExpression(TIntermTyped *baseExpression, const TSourceLoc& dotLocation, const TString &fieldString, const TSourceLoc& fieldLocation);
 
-    TTypeList *addStructDeclaratorList(const TPublicType& typeSpecifier, TTypeList *typeList);
-    TPublicType addStructure(const TSourceLoc& structLine, const TSourceLoc& nameLine, const TString &structName, TTypeList* typeList);
+    TFieldList *addStructDeclaratorList(const TPublicType& typeSpecifier, TFieldList *fieldList);
+    TPublicType addStructure(const TSourceLoc& structLine, const TSourceLoc& nameLine, const TString *structName, TFieldList* fieldList);
 
-    TIntermAggregate* addInterfaceBlock(const TPublicType& typeQualifier, const TSourceLoc& nameLine, const TString& blockName, TTypeList* typeList, 
-                                        const TString& instanceName, const TSourceLoc& instanceLine, TIntermTyped* arrayIndex, const TSourceLoc& arrayIndexLine);
+    TIntermAggregate* addInterfaceBlock(const TPublicType& typeQualifier, const TSourceLoc& nameLine, const TString& blockName, TFieldList* fieldList, 
+                                        const TString* instanceName, const TSourceLoc& instanceLine, TIntermTyped* arrayIndex, const TSourceLoc& arrayIndexLine);
 
     TLayoutQualifier parseLayoutQualifier(const TString &qualifierType, const TSourceLoc& qualifierTypeLine);
     TLayoutQualifier parseLayoutQualifier(const TString &qualifierType, const TSourceLoc& qualifierTypeLine, const TString &intValueString, int intValue, const TSourceLoc& intValueLine);
@@ -158,7 +158,7 @@ struct TParseContext {
     bool enterStructDeclaration(const TSourceLoc& line, const TString& identifier);
     void exitStructDeclaration();
 
-    bool structNestingErrorCheck(const TSourceLoc& line, const TType& fieldType);
+    bool structNestingErrorCheck(const TSourceLoc& line, const TField& field);
 };
 
 int PaParseStrings(size_t count, const char* const string[], const int length[],

src/compiler/SymbolTable.cpp

@@ -23,20 +23,19 @@ int TSymbolTableLevel::uniqueId = 0;
 
 TType::TType(const TPublicType &p) :
             type(p.type), precision(p.precision), qualifier(p.qualifier), primarySize(p.primarySize), secondarySize(p.secondarySize), array(p.array), layoutQualifier(p.layoutQualifier), arraySize(p.arraySize),
-            interfaceBlockType(0), structure(0), structureSize(0), deepestStructNesting(0), fieldName(0), mangled(0), typeName(0)
+            interfaceBlock(0), structure(0)
 {
     if (p.userDef) {
         structure = p.userDef->getStruct();
-        typeName = NewPoolTString(p.userDef->getTypeName().c_str());
-        computeDeepestStructNesting();
     }
 }
 
 //
 // Recursively generate mangled names.
 //
-void TType::buildMangledName(TString& mangledName)
+TString TType::buildMangledName() const
 {
+    TString mangledName;
     if (isMatrix())
         mangledName += 'm';
     else if (isVector())
@@ -45,7 +44,6 @@ void TType::buildMangledName(TString& mangledName)
     switch (type) {
     case EbtFloat:              mangledName += 'f';      break;
     case EbtInt:                mangledName += 'i';      break;
-    case EbtUInt:               mangledName += 'u';      break;
     case EbtBool:               mangledName += 'b';      break;
     case EbtSampler2D:          mangledName += "s2";     break;
     case EbtSampler3D:          mangledName += "s3";     break;
@@ -59,33 +57,9 @@ void TType::buildMangledName(TString& mangledName)
     case EbtUSampler3D:         mangledName += "us3";    break;
     case EbtUSamplerCube:       mangledName += "usC";    break;
     case EbtUSampler2DArray:    mangledName += "us2a";   break;
-    case EbtStruct:
-        mangledName += "struct-";
-        if (typeName)
-            mangledName += *typeName;
-        {// support MSVC++6.0
-            for (unsigned int i = 0; i < structure->size(); ++i) {
-                mangledName += '-';
-                (*structure)[i].type->buildMangledName(mangledName);
-            }
-        }
-        break;
-    case EbtInterfaceBlock:
-        {
-            mangledName += "interface-block-";
-            if (typeName)
-            {
-                mangledName += *typeName;
-            }
-            for (unsigned int i = 0; i < structure->size(); ++i)
-            {
-                mangledName += '-';
-                (*structure)[i].type->buildMangledName(mangledName);
-            }
-        }
-        break;
-    default:
-        break;
+    case EbtStruct:             mangledName += structure->mangledName(); break;
+    case EbtInterfaceBlock:     mangledName += interfaceBlock->mangledName(); break;
+    default:                    break;
     }
 
     if (isMatrix())
@@ -98,6 +72,7 @@ void TType::buildMangledName(TString& mangledName)
     {
         mangledName += static_cast<char>('0' + getNominalSize());
     }
+
     if (isArray()) {
         char buf[20];
         snprintf(buf, sizeof(buf), "%d", arraySize);
@@ -105,6 +80,7 @@ void TType::buildMangledName(TString& mangledName)
         mangledName += buf;
         mangledName += ']';
     }
+    return mangledName;
 }
 
 size_t TType::getObjectSize() const
@@ -112,7 +88,7 @@ size_t TType::getObjectSize() const
     size_t totalSize;
 
     if (getBasicType() == EbtStruct)
-        totalSize = getStructSize();
+        totalSize = structure->objectSize();
     else
         totalSize = primarySize * secondarySize;
 
@@ -127,57 +103,47 @@ size_t TType::getObjectSize() const
     return totalSize;
 }
 
-size_t TType::getStructSize() const
+bool TStructure::containsArrays() const
 {
-    if (!getStruct()) {
-        assert(false && "Not a struct");
-        return 0;
-    }
-
-    if (structureSize == 0) {
-        for (TTypeList::const_iterator tl = getStruct()->begin(); tl != getStruct()->end(); tl++) {
-            size_t fieldSize = ((*tl).type)->getObjectSize();
-            if (fieldSize > INT_MAX - structureSize)
-                structureSize = INT_MAX;
-            else
-                structureSize += fieldSize;
-        }
+    for (size_t i = 0; i < mFields->size(); ++i) {
+        const TType* fieldType = (*mFields)[i]->type();
+        if (fieldType->isArray() || fieldType->isStructureContainingArrays())
+            return true;
     }
-
-    return structureSize;
+    return false;
 }
 
-void TType::computeDeepestStructNesting()
+TString TFieldListCollection::buildMangledName() const
 {
-    if (!getStruct()) {
-        return;
-    }
-
-    int maxNesting = 0;
-    for (TTypeList::const_iterator tl = getStruct()->begin(); tl != getStruct()->end(); ++tl) {
-        maxNesting = std::max(maxNesting, ((*tl).type)->getDeepestStructNesting());
+    TString mangledName(mangledNamePrefix());
+    mangledName += *mName;
+    for (size_t i = 0; i < mFields->size(); ++i) {
+        mangledName += '-';
+        mangledName += (*mFields)[i]->type()->getMangledName();
     }
-
-    deepestStructNesting = 1 + maxNesting;
+    return mangledName;
 }
 
-bool TType::isStructureContainingArrays() const
+size_t TFieldListCollection::calculateObjectSize() const
 {
-    if (!structure)
-    {
-        return false;
+    size_t size = 0;
+    for (size_t i = 0; i < mFields->size(); ++i) {
+        size_t fieldSize = (*mFields)[i]->type()->getObjectSize();
+        if (fieldSize > INT_MAX - size)
+            size = INT_MAX;
+        else
+            size += fieldSize;
     }
+    return size;
+}
 
-    for (TTypeList::const_iterator member = structure->begin(); member != structure->end(); member++)
-    {
-        if (member->type->isArray() ||
-            member->type->isStructureContainingArrays())
-        {
-            return true;
-        }
+int TStructure::calculateDeepestNesting() const
+{
+    int maxNesting = 0;
+    for (size_t i = 0; i < mFields->size(); ++i) {
+        maxNesting = std::max(maxNesting, (*mFields)[i]->type()->getDeepestStructNesting());
     }
-
-    return false;
+    return 1 + maxNesting;
 }
 
 //

src/compiler/Types.h

@@ -7,28 +7,131 @@
 #ifndef _TYPES_INCLUDED
 #define _TYPES_INCLUDED
 
+#include "common/angleutils.h"
+
 #include "compiler/BaseTypes.h"
 #include "compiler/Common.h"
 #include "compiler/debug.h"
 
-class TType;
 struct TPublicType;
+class TType;
 
-//
-// Need to have association of line numbers to types in a list for building structs.
-//
-struct TTypeLine {
-    TType* type;
-    TSourceLoc line;
+class TField
+{
+public:
+    POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator);
+    TField(TType* type, TString* name, const TSourceLoc& line) : mType(type), mName(name), mLine(line) {}
+
+    // TODO(alokp): We should only return const type.
+    // Fix it by tweaking grammar.
+    TType* type() { return mType; }
+    const TType* type() const { return mType; }
+
+    const TString& name() const { return *mName; }
+    const TSourceLoc& line() const { return mLine; }
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(TField);
+    TType* mType;
+    TString* mName;
+    TSourceLoc mLine;
 };
-typedef TVector<TTypeLine> TTypeList;
 
-inline TTypeList* NewPoolTTypeList()
+typedef TVector<TField*> TFieldList;
+inline TFieldList* NewPoolTFieldList()
 {
-    void* memory = GlobalPoolAllocator.allocate(sizeof(TTypeList));
-    return new(memory) TTypeList;
+    void* memory = GlobalPoolAllocator.allocate(sizeof(TFieldList));
+    return new(memory) TFieldList;
 }
 
+class TFieldListCollection
+{
+public:
+    const TString& name() const { return *mName; }
+    const TFieldList& fields() const { return *mFields; }
+
+    const TString& mangledName() const {
+        if (mMangledName.empty())
+            mMangledName = buildMangledName();
+        return mMangledName;
+    }
+    size_t objectSize() const {
+        if (mObjectSize == 0)
+            mObjectSize = calculateObjectSize();
+        return mObjectSize;
+    };
+
+protected:
+    TFieldListCollection(const TString* name, TFieldList* fields)
+        : mName(name),
+          mFields(fields),
+          mObjectSize(0) {
+    }
+    TString buildMangledName() const;
+    size_t calculateObjectSize() const;
+    virtual TString mangledNamePrefix() const = 0;
+
+    const TString* mName;
+    TFieldList* mFields;
+
+    mutable TString mMangledName;
+    mutable size_t mObjectSize;
+};
+
+// May also represent interface blocks
+class TStructure : public TFieldListCollection
+{
+public:
+    POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator);
+    TStructure(const TString* name, TFieldList* fields)
+        : TFieldListCollection(name, fields),
+          mDeepestNesting(0) {
+    }
+
+    int deepestNesting() const {
+        if (mDeepestNesting == 0)
+            mDeepestNesting = calculateDeepestNesting();
+        return mDeepestNesting;
+    }
+    bool containsArrays() const;
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(TStructure);
+    virtual TString mangledNamePrefix() const { return "struct-"; }
+    int calculateDeepestNesting() const;
+
+    mutable int mDeepestNesting;
+};
+
+class TInterfaceBlock : public TFieldListCollection
+{
+public:
+    POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator);
+    TInterfaceBlock(const TString* name, TFieldList* fields, const TString* instanceName, int arraySize, const TLayoutQualifier& layoutQualifier)
+        : TFieldListCollection(name, fields),
+          mInstanceName(instanceName),
+          mArraySize(arraySize),
+          mBlockStorage(layoutQualifier.blockStorage),
+          mMatrixPacking(layoutQualifier.matrixPacking) {
+    }
+
+    const TString& instanceName() const { return *mInstanceName; }
+    bool hasInstanceName() const { return mInstanceName != NULL; }
+    bool isArray() const { return mArraySize > 0; }
+    int arraySize() const { return mArraySize; }
+    TLayoutBlockStorage blockStorage() const { return mBlockStorage; }
+    TLayoutMatrixPacking matrixPacking() const { return mMatrixPacking; }
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(TInterfaceBlock);
+    virtual TString mangledNamePrefix() const { return "iblock-"; }
+
+    const TString* mInstanceName; // for interface block instance names
+    int mArraySize; // 0 if not an array
+    TLayoutBlockStorage mBlockStorage;
+    TLayoutMatrixPacking mMatrixPacking;
+};
+
 //
 // Base class for things that have a type.
 //
@@ -39,15 +142,19 @@ public:
     TType() {}
     TType(TBasicType t, TPrecision p, TQualifier q = EvqTemporary, int ps = 1, int ss = 1, bool a = false) :
             type(t), precision(p), qualifier(q), primarySize(ps), secondarySize(ss), array(a), layoutQualifier(TLayoutQualifier::create()), arraySize(0),
-            interfaceBlockType(0), structure(0), structureSize(0), deepestStructNesting(0), fieldName(0), mangled(0), typeName(0), instanceName(0)
+            interfaceBlock(0), structure(0)
     {
     }
     explicit TType(const TPublicType &p);
-    TType(TTypeList* userDef, const TString& n, TPrecision p = EbpUndefined) :
+    TType(TStructure* userDef, TPrecision p = EbpUndefined) :
             type(EbtStruct), precision(p), qualifier(EvqTemporary), primarySize(1), secondarySize(1), array(false), layoutQualifier(TLayoutQualifier::create()), arraySize(0),
-            interfaceBlockType(0), structure(userDef), structureSize(0), deepestStructNesting(0), fieldName(0), mangled(0), instanceName(0)
+            interfaceBlock(0), structure(userDef)
+    {
+    }
+    TType(TInterfaceBlock* interfaceBlockIn, TQualifier qualifierIn, TLayoutQualifier layoutQualifierIn, int arraySizeIn) :
+            type(EbtInterfaceBlock), precision(EbpUndefined), qualifier(qualifierIn), primarySize(1), secondarySize(1), array(arraySizeIn > 0), layoutQualifier(layoutQualifierIn), arraySize(arraySizeIn),
+            interfaceBlock(interfaceBlockIn), structure(0)
     {
-        typeName = NewPoolTString(n.c_str());
     }
 
     TBasicType getBasicType() const { return type; }
@@ -74,15 +181,14 @@ public:
 
     int elementRegisterCount() const
     {
-        TTypeList *structure = getStruct();
-
         if (structure)
         {
+            const TFieldList& fields = structure->fields();
             int registerCount = 0;
 
-            for (size_t i = 0; i < structure->size(); i++)
+            for (size_t i = 0; i < fields.size(); i++)
             {
-                registerCount += (*structure)[i].type->totalRegisterCount();
+                registerCount += fields[i]->type()->totalRegisterCount();
             }
 
             return registerCount;
@@ -114,65 +220,25 @@ public:
     int getArraySize() const { return arraySize; }
     void setArraySize(int s) { array = true; arraySize = s; }
     void clearArrayness() { array = false; arraySize = 0; }
-    void setInterfaceBlockType(TType* t) { interfaceBlockType = t; }
-    TType* getInterfaceBlockType() const { return interfaceBlockType; }
-    bool isInterfaceBlockMember() const { return interfaceBlockType != NULL; }
+
+    TInterfaceBlock* getInterfaceBlock() const { return interfaceBlock; }
+    void setInterfaceBlock(TInterfaceBlock* interfaceBlockIn) { interfaceBlock = interfaceBlockIn; }
+    bool isInterfaceBlock() const { return type == EbtInterfaceBlock; }
 
     bool isVector() const { return primarySize > 1 && secondarySize == 1; }
     bool isScalar() const { return primarySize == 1 && secondarySize == 1 && !structure; }
     bool isScalarInt() const { return isScalar() && (type == EbtInt || type == EbtUInt); }
 
-    TTypeList* getStruct() const { return structure; }
-    void setStruct(TTypeList* s) { structure = s; computeDeepestStructNesting(); }
-
-    const TString& getTypeName() const
-    {
-        assert(typeName);
-        return *typeName;
-    }
-    void setTypeName(const TString& n)
-    {
-        typeName = NewPoolTString(n.c_str());
-    }
-
-    bool isField() const { return fieldName != 0; }
-    const TString& getFieldName() const
-    {
-        assert(fieldName);
-        return *fieldName;
-    }
-    void setFieldName(const TString& n)
-    {
-        fieldName = NewPoolTString(n.c_str());
-    }
-
-    TString& getMangledName() {
-        if (!mangled) {
-            mangled = NewPoolTString("");
-            buildMangledName(*mangled);
-            *mangled += ';' ;
-        }
-
-        return *mangled;
-    }
+    TStructure* getStruct() const { return structure; }
+    void setStruct(TStructure* s) { structure = s; }
 
-    void setInstanceName(const TString& n)
-    {
-        assert(type == EbtInterfaceBlock);
-        instanceName = NewPoolTString(n.c_str());
+    const TString& getMangledName() {
+        if (mangled.empty()) {
+            mangled = buildMangledName();
+            mangled += ';';
         }
 
-    bool hasInstanceName() const
-    {
-        assert(type == EbtInterfaceBlock);
-        return instanceName != NULL;
-    }
-
-    const TString& getInstanceName() const
-    {
-        assert(type == EbtInterfaceBlock);
-        assert(instanceName);
-        return *instanceName;
+        return mangled;
     }
 
     bool sameElementType(const TType& right) const {
@@ -220,12 +286,16 @@ public:
     // For type "nesting2", this method would return 2 -- the number
     // of structures through which indirection must occur to reach the
     // deepest field (nesting2.field1.position).
-    int getDeepestStructNesting() const { return deepestStructNesting; }
+    int getDeepestStructNesting() const {
+        return structure ? structure->deepestNesting() : 0;
+    }
 
-    bool isStructureContainingArrays() const;
+    bool isStructureContainingArrays() const {
+        return structure ? structure->containsArrays() : false;
+    }
 
-private:
-    void buildMangledName(TString&);
+protected:
+    TString buildMangledName() const;
     size_t getStructSize() const;
     void computeDeepestStructNesting();
 
@@ -237,16 +307,14 @@ private:
     int primarySize; // size of vector or cols matrix
     int secondarySize; // rows of a matrix
     int arraySize;
-    TType* interfaceBlockType;
 
-    TTypeList* structure;      // 0 unless this is a struct
-    mutable size_t structureSize;
-    int deepestStructNesting;
+    // 0 unless this is an interface block, or interface block member variable
+    TInterfaceBlock* interfaceBlock;
+
+    // 0 unless this is a struct
+    TStructure* structure;
 
-    TString *fieldName;         // for structure field names
-    TString *mangled;
-    TString *typeName;          // for structure field type name
-    TString *instanceName;      // for interface block instance names
+    mutable TString mangled;
 };
 
 //

src/compiler/VariableInfo.cpp

@@ -173,14 +173,15 @@ void getUserDefinedVariableInfo(const TType& type,
                                 TVariableInfoList& infoList,
                                 ShHashFunction64 hashFunction)
 {
-    ASSERT(type.getBasicType() == EbtStruct);
+    ASSERT(type.getBasicType() == EbtStruct || type.isInterfaceBlock());
 
-    const TTypeList* structure = type.getStruct();
-    for (size_t i = 0; i < structure->size(); ++i) {
-        const TType* fieldType = (*structure)[i].type;
-        getVariableInfo(*fieldType,
-                        name + "." + fieldType->getFieldName(),
-                        mappedName + "." + TIntermTraverser::hash(fieldType->getFieldName(), hashFunction),
+    const TFieldList& fields = type.getStruct()->fields();
+    for (size_t i = 0; i < fields.size(); ++i) {
+        const TType& fieldType = *(fields[i]->type());
+        const TString& fieldName = fields[i]->name();
+        getVariableInfo(fieldType,
+                        name + "." + fieldName,
+                        mappedName + "." + TIntermTraverser::hash(fieldName, hashFunction),
                         infoList,
                         hashFunction);
     }

src/compiler/glslang.y

@@ -79,8 +79,8 @@ WHICH GENERATES THE GLSL ES PARSER (glslang_tab.cpp AND glslang_tab.h).
             TQualifier qualifier;
             TFunction* function;
             TParameter param;
-            TTypeLine typeLine;
-            TTypeList* typeList;
+            TField* field;
+            TFieldList* fieldList;
         };
     } interm;
 }
@@ -189,8 +189,8 @@ extern void yyerror(YYLTYPE* yylloc, TParseContext* context, const char* reason)
 %type <interm.type> type_qualifier fully_specified_type type_specifier storage_qualifier interpolation_qualifier
 %type <interm.type> type_specifier_no_prec type_specifier_nonarray
 %type <interm.type> struct_specifier
-%type <interm.typeLine> struct_declarator
-%type <interm.typeList> struct_declarator_list struct_declaration struct_declaration_list
+%type <interm.field> struct_declarator
+%type <interm.fieldList> struct_declarator_list struct_declaration struct_declaration_list
 %type <interm.function> function_header function_declarator function_identifier
 %type <interm.function> function_header_with_parameters function_call_header
 %type <interm> function_call_header_with_parameters function_call_header_no_parameters function_call_generic function_prototype
@@ -818,15 +818,15 @@ declaration
     }
     | type_qualifier enter_struct struct_declaration_list RIGHT_BRACE SEMICOLON {
         ES3_ONLY(getQualifierString($1.qualifier), @1, "interface blocks");
-        $$ = context->addInterfaceBlock($1, @2, *$2.string, $3, "", @$, NULL, @$);
+        $$ = context->addInterfaceBlock($1, @2, *$2.string, $3, NULL, @$, NULL, @$);
     }
     | type_qualifier enter_struct struct_declaration_list RIGHT_BRACE IDENTIFIER SEMICOLON {
         ES3_ONLY(getQualifierString($1.qualifier), @1, "interface blocks");
-        $$ = context->addInterfaceBlock($1, @2, *$2.string, $3, *$5.string, @5, NULL, @$);
+        $$ = context->addInterfaceBlock($1, @2, *$2.string, $3, $5.string, @5, NULL, @$);
     }
     | type_qualifier enter_struct struct_declaration_list RIGHT_BRACE IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET SEMICOLON {
         ES3_ONLY(getQualifierString($1.qualifier), @1, "interface blocks");
-        $$ = context->addInterfaceBlock($1, @2, *$2.string, $3, *$5.string, @5, $7, @6);
+        $$ = context->addInterfaceBlock($1, @2, *$2.string, $3, $5.string, @5, $7, @6);
     }
     | type_qualifier SEMICOLON {
         context->parseGlobalLayoutQualifier($1);
@@ -1519,10 +1519,10 @@ type_specifier_nonarray
 
 struct_specifier
     : STRUCT identifier LEFT_BRACE { if (context->enterStructDeclaration(@2, *$2.string)) context->recover(); } struct_declaration_list RIGHT_BRACE {
-        $$ = context->addStructure(@1, @2, *$2.string, $5);
+        $$ = context->addStructure(@1, @2, $2.string, $5);
     }
     | STRUCT LEFT_BRACE { if (context->enterStructDeclaration(@2, *$2.string)) context->recover(); } struct_declaration_list RIGHT_BRACE {
-        $$ = context->addStructure(@1, @$, "", $4);
+        $$ = context->addStructure(@1, @$, NewPoolTString(""), $4);
     }
     ;
 
@@ -1532,14 +1532,15 @@ struct_declaration_list
     }
     | struct_declaration_list struct_declaration {
         $$ = $1;
-        for (unsigned int i = 0; i < $2->size(); ++i) {
-            for (unsigned int j = 0; j < $$->size(); ++j) {
-                if ((*$$)[j].type->getFieldName() == (*$2)[i].type->getFieldName()) {
-                    context->error((*$2)[i].line, "duplicate field name in structure:", "struct", (*$2)[i].type->getFieldName().c_str());
+        for (size_t i = 0; i < $2->size(); ++i) {
+            TField* field = (*$2)[i];
+            for (size_t j = 0; j < $$->size(); ++j) {
+                if ((*$$)[j]->name() == field->name()) {
+                    context->error(@2, "duplicate field name in structure:", "struct", field->name().c_str());
                     context->recover();
                 }
             }
-            $$->push_back((*$2)[i]);
+            $$->push_back(field);
         }
     }
     ;
@@ -1558,7 +1559,7 @@ struct_declaration
 
 struct_declarator_list
     : struct_declarator {
-        $$ = NewPoolTTypeList();
+        $$ = NewPoolTFieldList();
         $$->push_back($1);
     }
     | struct_declarator_list COMMA struct_declarator {
@@ -1571,20 +1572,20 @@ struct_declarator
         if (context->reservedErrorCheck(@1, *$1.string))
             context->recover();
 
-        $$.type = new TType(EbtVoid, EbpUndefined);
-        $$.type->setFieldName(*$1.string);
+        TType* type = new TType(EbtVoid, EbpUndefined);
+        $$ = new TField(type, $1.string, @1);
     }
     | identifier LEFT_BRACKET constant_expression RIGHT_BRACKET {
         if (context->reservedErrorCheck(@1, *$1.string))
             context->recover();
 
-        $$.type = new TType(EbtVoid, EbpUndefined);
-        $$.type->setFieldName(*$1.string);
-
+        TType* type = new TType(EbtVoid, EbpUndefined);
         int size;
-        if (context->arraySizeErrorCheck(@2, $3, size))
+        if (context->arraySizeErrorCheck(@3, $3, size))
             context->recover();
-        $$.type->setArraySize(size);
+        type->setArraySize(size);
+
+        $$ = new TField(type, $1.string, @1);
     }
     ;
 

src/compiler/glslang_tab.cpp

@@ -294,8 +294,8 @@ typedef union YYSTYPE
             TQualifier qualifier;
             TFunction* function;
             TParameter param;
-            TTypeLine typeLine;
-            TTypeList* typeList;
+            TField* field;
+            TFieldList* fieldList;
         };
     } interm;
 
@@ -808,13 +808,13 @@ static const yytype_uint16 yyrline[] =
     1355,  1360,  1365,  1370,  1375,  1380,  1385,  1390,  1395,  1400,
     1405,  1410,  1415,  1420,  1425,  1430,  1435,  1440,  1444,  1448,
     1452,  1456,  1460,  1464,  1468,  1472,  1476,  1480,  1484,  1488,
-    1496,  1504,  1508,  1521,  1521,  1524,  1524,  1530,  1533,  1548,
-    1551,  1560,  1564,  1570,  1577,  1592,  1596,  1600,  1601,  1607,
-    1608,  1609,  1610,  1611,  1615,  1616,  1616,  1616,  1626,  1627,
-    1631,  1631,  1632,  1632,  1637,  1640,  1650,  1653,  1659,  1660,
-    1664,  1672,  1676,  1686,  1691,  1708,  1708,  1713,  1713,  1720,
-    1720,  1728,  1731,  1737,  1740,  1746,  1750,  1757,  1764,  1771,
-    1778,  1789,  1798,  1802,  1809,  1812,  1818,  1818
+    1496,  1504,  1508,  1521,  1521,  1524,  1524,  1530,  1533,  1549,
+    1552,  1561,  1565,  1571,  1578,  1593,  1597,  1601,  1602,  1608,
+    1609,  1610,  1611,  1612,  1616,  1617,  1617,  1617,  1627,  1628,
+    1632,  1632,  1633,  1633,  1638,  1641,  1651,  1654,  1660,  1661,
+    1665,  1673,  1677,  1687,  1692,  1709,  1709,  1714,  1714,  1721,
+    1721,  1729,  1732,  1738,  1741,  1747,  1751,  1758,  1765,  1772,
+    1779,  1790,  1799,  1803,  1810,  1813,  1819,  1819
 };
 #endif
 
@@ -3333,7 +3333,7 @@ yyreduce:
 
     {
         ES3_ONLY(getQualifierString((yyvsp[(1) - (5)].interm.type).qualifier), (yylsp[(1) - (5)]), "interface blocks");
-        (yyval.interm.intermNode) = context->addInterfaceBlock((yyvsp[(1) - (5)].interm.type), (yylsp[(2) - (5)]), *(yyvsp[(2) - (5)].lex).string, (yyvsp[(3) - (5)].interm.typeList), "", (yyloc), NULL, (yyloc));
+        (yyval.interm.intermNode) = context->addInterfaceBlock((yyvsp[(1) - (5)].interm.type), (yylsp[(2) - (5)]), *(yyvsp[(2) - (5)].lex).string, (yyvsp[(3) - (5)].interm.fieldList), NULL, (yyloc), NULL, (yyloc));
     }
     break;
 
@@ -3341,7 +3341,7 @@ yyreduce:
 
     {
         ES3_ONLY(getQualifierString((yyvsp[(1) - (6)].interm.type).qualifier), (yylsp[(1) - (6)]), "interface blocks");
-        (yyval.interm.intermNode) = context->addInterfaceBlock((yyvsp[(1) - (6)].interm.type), (yylsp[(2) - (6)]), *(yyvsp[(2) - (6)].lex).string, (yyvsp[(3) - (6)].interm.typeList), *(yyvsp[(5) - (6)].lex).string, (yylsp[(5) - (6)]), NULL, (yyloc));
+        (yyval.interm.intermNode) = context->addInterfaceBlock((yyvsp[(1) - (6)].interm.type), (yylsp[(2) - (6)]), *(yyvsp[(2) - (6)].lex).string, (yyvsp[(3) - (6)].interm.fieldList), (yyvsp[(5) - (6)].lex).string, (yylsp[(5) - (6)]), NULL, (yyloc));
     }
     break;
 
@@ -3349,7 +3349,7 @@ yyreduce:
 
     {
         ES3_ONLY(getQualifierString((yyvsp[(1) - (9)].interm.type).qualifier), (yylsp[(1) - (9)]), "interface blocks");
-        (yyval.interm.intermNode) = context->addInterfaceBlock((yyvsp[(1) - (9)].interm.type), (yylsp[(2) - (9)]), *(yyvsp[(2) - (9)].lex).string, (yyvsp[(3) - (9)].interm.typeList), *(yyvsp[(5) - (9)].lex).string, (yylsp[(5) - (9)]), (yyvsp[(7) - (9)].interm.intermTypedNode), (yylsp[(6) - (9)]));
+        (yyval.interm.intermNode) = context->addInterfaceBlock((yyvsp[(1) - (9)].interm.type), (yylsp[(2) - (9)]), *(yyvsp[(2) - (9)].lex).string, (yyvsp[(3) - (9)].interm.fieldList), (yyvsp[(5) - (9)].lex).string, (yylsp[(5) - (9)]), (yyvsp[(7) - (9)].interm.intermTypedNode), (yylsp[(6) - (9)]));
     }
     break;
 
@@ -4381,7 +4381,7 @@ yyreduce:
   case 184:
 
     {
-        (yyval.interm.type) = context->addStructure((yylsp[(1) - (6)]), (yylsp[(2) - (6)]), *(yyvsp[(2) - (6)].lex).string, (yyvsp[(5) - (6)].interm.typeList));
+        (yyval.interm.type) = context->addStructure((yylsp[(1) - (6)]), (yylsp[(2) - (6)]), (yyvsp[(2) - (6)].lex).string, (yyvsp[(5) - (6)].interm.fieldList));
     }
     break;
 
@@ -4393,29 +4393,30 @@ yyreduce:
   case 186:
 
     {
-        (yyval.interm.type) = context->addStructure((yylsp[(1) - (5)]), (yyloc), "", (yyvsp[(4) - (5)].interm.typeList));
+        (yyval.interm.type) = context->addStructure((yylsp[(1) - (5)]), (yyloc), NewPoolTString(""), (yyvsp[(4) - (5)].interm.fieldList));
     }
     break;
 
   case 187:
 
     {
-        (yyval.interm.typeList) = (yyvsp[(1) - (1)].interm.typeList);
+        (yyval.interm.fieldList) = (yyvsp[(1) - (1)].interm.fieldList);
     }
     break;
 
   case 188:
 
     {
-        (yyval.interm.typeList) = (yyvsp[(1) - (2)].interm.typeList);
-        for (unsigned int i = 0; i < (yyvsp[(2) - (2)].interm.typeList)->size(); ++i) {
-            for (unsigned int j = 0; j < (yyval.interm.typeList)->size(); ++j) {
-                if ((*(yyval.interm.typeList))[j].type->getFieldName() == (*(yyvsp[(2) - (2)].interm.typeList))[i].type->getFieldName()) {
-                    context->error((*(yyvsp[(2) - (2)].interm.typeList))[i].line, "duplicate field name in structure:", "struct", (*(yyvsp[(2) - (2)].interm.typeList))[i].type->getFieldName().c_str());
+        (yyval.interm.fieldList) = (yyvsp[(1) - (2)].interm.fieldList);
+        for (size_t i = 0; i < (yyvsp[(2) - (2)].interm.fieldList)->size(); ++i) {
+            TField* field = (*(yyvsp[(2) - (2)].interm.fieldList))[i];
+            for (size_t j = 0; j < (yyval.interm.fieldList)->size(); ++j) {
+                if ((*(yyval.interm.fieldList))[j]->name() == field->name()) {
+                    context->error((yylsp[(2) - (2)]), "duplicate field name in structure:", "struct", field->name().c_str());
                     context->recover();
                 }
             }
-            (yyval.interm.typeList)->push_back((*(yyvsp[(2) - (2)].interm.typeList))[i]);
+            (yyval.interm.fieldList)->push_back(field);
         }
     }
     break;
@@ -4423,7 +4424,7 @@ yyreduce:
   case 189:
 
     {
-        (yyval.interm.typeList) = context->addStructDeclaratorList((yyvsp[(1) - (3)].interm.type), (yyvsp[(2) - (3)].interm.typeList));
+        (yyval.interm.fieldList) = context->addStructDeclaratorList((yyvsp[(1) - (3)].interm.type), (yyvsp[(2) - (3)].interm.fieldList));
     }
     break;
 
@@ -4433,22 +4434,22 @@ yyreduce:
         // ES3 Only, but errors should be handled elsewhere
         (yyvsp[(2) - (4)].interm.type).qualifier = (yyvsp[(1) - (4)].interm.type).qualifier;
         (yyvsp[(2) - (4)].interm.type).layoutQualifier = (yyvsp[(1) - (4)].interm.type).layoutQualifier;
-        (yyval.interm.typeList) = context->addStructDeclaratorList((yyvsp[(2) - (4)].interm.type), (yyvsp[(3) - (4)].interm.typeList));
+        (yyval.interm.fieldList) = context->addStructDeclaratorList((yyvsp[(2) - (4)].interm.type), (yyvsp[(3) - (4)].interm.fieldList));
     }
     break;
 
   case 191:
 
     {
-        (yyval.interm.typeList) = NewPoolTTypeList();
-        (yyval.interm.typeList)->push_back((yyvsp[(1) - (1)].interm.typeLine));
+        (yyval.interm.fieldList) = NewPoolTFieldList();
+        (yyval.interm.fieldList)->push_back((yyvsp[(1) - (1)].interm.field));
     }
     break;
 
   case 192:
 
     {
-        (yyval.interm.typeList)->push_back((yyvsp[(3) - (3)].interm.typeLine));
+        (yyval.interm.fieldList)->push_back((yyvsp[(3) - (3)].interm.field));
     }
     break;
 
@@ -4458,8 +4459,8 @@ yyreduce:
         if (context->reservedErrorCheck((yylsp[(1) - (1)]), *(yyvsp[(1) - (1)].lex).string))
             context->recover();
 
-        (yyval.interm.typeLine).type = new TType(EbtVoid, EbpUndefined);
-        (yyval.interm.typeLine).type->setFieldName(*(yyvsp[(1) - (1)].lex).string);
+        TType* type = new TType(EbtVoid, EbpUndefined);
+        (yyval.interm.field) = new TField(type, (yyvsp[(1) - (1)].lex).string, (yylsp[(1) - (1)]));
     }
     break;
 
@@ -4469,13 +4470,13 @@ yyreduce:
         if (context->reservedErrorCheck((yylsp[(1) - (4)]), *(yyvsp[(1) - (4)].lex).string))
             context->recover();
 
-        (yyval.interm.typeLine).type = new TType(EbtVoid, EbpUndefined);
-        (yyval.interm.typeLine).type->setFieldName(*(yyvsp[(1) - (4)].lex).string);
-
+        TType* type = new TType(EbtVoid, EbpUndefined);
         int size;
-        if (context->arraySizeErrorCheck((yylsp[(2) - (4)]), (yyvsp[(3) - (4)].interm.intermTypedNode), size))
+        if (context->arraySizeErrorCheck((yylsp[(3) - (4)]), (yyvsp[(3) - (4)].interm.intermTypedNode), size))
             context->recover();
-        (yyval.interm.typeLine).type->setArraySize(size);
+        type->setArraySize(size);
+
+        (yyval.interm.field) = new TField(type, (yyvsp[(1) - (4)].lex).string, (yylsp[(1) - (4)]));
     }
     break;
 

src/compiler/glslang_tab.h

@@ -211,8 +211,8 @@ typedef union YYSTYPE
             TQualifier qualifier;
             TFunction* function;
             TParameter param;
-            TTypeLine typeLine;
-            TTypeList* typeList;
+            TField* field;
+            TFieldList* fieldList;
         };
     } interm;
 

src/compiler/intermediate.h

@@ -271,6 +271,7 @@ public:
     int getNominalSize() const { return type.getNominalSize(); }
     int getSecondarySize() const { return type.getSecondarySize(); }
     
+    bool isInterfaceBlock() const { return type.isInterfaceBlock(); }
     bool isMatrix() const { return type.isMatrix(); }
     bool isArray()  const { return type.isArray(); }
     bool isVector() const { return type.isVector(); }