diff --git a/Test/baseResults/150.geom.out b/Test/baseResults/150.geom.out new file mode 100644 index 00000000..4fb259c9 --- /dev/null +++ b/Test/baseResults/150.geom.out @@ -0,0 +1,17 @@ +Warning, version 150 is not yet complete; some version-specific features are present, but many are missing. +ERROR: 0:7: 'EmitStreamVertex' : no matching overloaded function found +ERROR: 0:8: 'EndStreamPrimitive' : no matching overloaded function found +ERROR: 2 compilation errors. No code generated. + +ERROR: node is still EOpNull! +0:3 Function Definition: main( (void) +0:3 Function Parameters: +0:5 Sequence +0:5 EmitVertex (void) +0:6 EndPrimitive (void) +0:7 Constant: +0:7 0.000000 +0:8 Constant: +0:8 0.000000 +0:? Linker Objects + diff --git a/Test/testlist b/Test/testlist index 8df40882..26e7b00e 100644 --- a/Test/testlist +++ b/Test/testlist @@ -12,6 +12,7 @@ versionsErrors.vert 120.frag 130.frag 140.frag +150.geom precision.frag precision.vert nonSquare.vert diff --git a/glslang/Include/BaseTypes.h b/glslang/Include/BaseTypes.h index 965c4bdb..0790a898 100644 --- a/glslang/Include/BaseTypes.h +++ b/glslang/Include/BaseTypes.h @@ -68,7 +68,7 @@ enum TStorageQualifier { EvqVaryingIn, // pipeline input, read only EvqVaryingOut, // pipeline ouput, read/write EvqUniform, // read only, shader with app - EVqBuffer, // read only, shader with app + EvqBuffer, // read only, shader with app // parameters EvqIn, diff --git a/glslang/Include/ConstantUnion.h b/glslang/Include/ConstantUnion.h index c179a58c..53a5e930 100644 --- a/glslang/Include/ConstantUnion.h +++ b/glslang/Include/ConstantUnion.h @@ -452,6 +452,9 @@ public: if (unionArray == rhs.unionArray) return true; + if (! unionArray || ! rhs.unionArray) + return false; + return *unionArray == *rhs.unionArray; } bool operator!=(const TConstUnionArray& rhs) const { return ! operator==(rhs); } diff --git a/glslang/Include/Types.h b/glslang/Include/Types.h index 11e43a29..1d341c95 100644 --- a/glslang/Include/Types.h +++ b/glslang/Include/Types.h @@ -300,7 +300,7 @@ public: { switch (storage) { case EvqUniform: - case EVqBuffer: + case EvqBuffer: return true; default: return false; @@ -479,7 +479,7 @@ public: typeName = copyOf.typeName; } - void deepCopy(const TType& copyOf, const TStructureMap& remapper) + void deepCopy(const TType& copyOf) { shallowCopy(copyOf); @@ -489,18 +489,14 @@ public: } if (structure) { + structure = NewPoolTTypeList(); TStructureMapIterator iter; - if ((iter = remapper.find(structure)) == remapper.end()) { - // create the new structure here - structure = NewPoolTTypeList(); - for (unsigned int i = 0; i < copyOf.structure->size(); ++i) { - TTypeLoc typeLoc; - typeLoc.loc = (*copyOf.structure)[i].loc; - typeLoc.type = (*copyOf.structure)[i].type->clone(remapper); - structure->push_back(typeLoc); - } - } else { - structure = iter->second; + for (unsigned int i = 0; i < copyOf.structure->size(); ++i) { + TTypeLoc typeLoc; + typeLoc.loc = (*copyOf.structure)[i].loc; + typeLoc.type = new TType(); + typeLoc.type->deepCopy(*(*copyOf.structure)[i].type); + structure->push_back(typeLoc); } } @@ -509,6 +505,14 @@ public: if (typeName) typeName = NewPoolTString(copyOf.typeName->c_str()); } + + TType* clone() + { + TType *newType = new TType(); + newType->deepCopy(*this); + + return newType; + } // Merge type from parent, where a parentType is at the beginning of a declaration, // establishing some charastics for all subsequent names, while this type @@ -525,14 +529,6 @@ public: setTypeName(parentType.userDef->getTypeName()); } - TType* clone(const TStructureMap& remapper) - { - TType *newType = new TType(); - newType->deepCopy(*this, remapper); - - return newType; - } - virtual void dereference() { if (arraySizes) @@ -578,8 +574,12 @@ public: virtual int getMatrixCols() const { return matrixCols; } virtual int getMatrixRows() const { return matrixRows; } + virtual bool isScalar() const { return vectorSize == 1 && ! getStruct() && ! isArray(); } + virtual bool isVector() const { return vectorSize > 1; } virtual bool isMatrix() const { return matrixCols ? true : false; } - virtual bool isArray() const { return arraySizes != 0; } + virtual bool isArray() const { return arraySizes != 0; } + + // Recursively check the structure for any arrays, needed for some error checks virtual bool containsArray() const { if (isArray()) @@ -593,11 +593,18 @@ public: return false; } int getArraySize() const { return arraySizes->sizes.front(); } - void setArraySizes(TArraySizes* s) + void shareArraySizes(const TType& type) { - // copy; we don't want distinct types sharing the same descriptor - if (! arraySizes) - arraySizes = NewPoolTArraySizes(); + // For when we are sharing existing array descriptors. + // This allows all references to the same unsized array + // to be updated at once, by having all of them share the + // array description. + *arraySizes = *type.arraySizes; + } + void setArraySizes(TArraySizes* s) + { + // For when we don't want distinct types sharing the same descriptor. + arraySizes = NewPoolTArraySizes(); *arraySizes = *s; } void setArraySizes(const TType& type) { setArraySizes(type.arraySizes); } @@ -605,8 +612,6 @@ public: void changeArraySize(int s) { arraySizes->sizes.front() = s; } void setMaxArraySize (int s) { arraySizes->maxArraySize = s; } int getMaxArraySize () const { return arraySizes->maxArraySize; } - virtual bool isVector() const { return vectorSize > 1; } - virtual bool isScalar() const { return vectorSize == 1; } const char* getBasicString() const { return TType::getBasicString(basicType); diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp index e184af70..e37c41d6 100644 --- a/glslang/MachineIndependent/ParseHelper.cpp +++ b/glslang/MachineIndependent/ParseHelper.cpp @@ -1757,7 +1757,7 @@ void TParseContext::declareArray(TSourceLoc loc, TString& identifier, const TTyp return; } - variable->getWritableType().setArraySizes(type); + variable->getWritableType().shareArraySizes(type); } bool TParseContext::arraySetMaxSize(TSourceLoc loc, TIntermSymbol *node, int size) @@ -2171,7 +2171,7 @@ TIntermTyped* TParseContext::addConstructor(TIntermNode* node, const TType& type TType elementType; elementType.shallowCopy(type); if (type.isArray()) - elementType.dereference(); // TODO: arrays of arrays: shallow copy won't work if sharing same array structure and then doing a dereference + elementType.dereference(); // TODO: arrays of arrays: combine this with shallowCopy bool singleArg; if (aggrNode) { @@ -2202,7 +2202,7 @@ TIntermTyped* TParseContext::addConstructor(TIntermNode* node, const TType& type // // Handle list of arguments. // - TIntermSequence &sequenceVector = aggrNode->getSequence() ; // Stores the information about the parameter to the constructor + TIntermSequence &sequenceVector = aggrNode->getSequence(); // Stores the information about the parameter to the constructor // if the structure constructor contains more than one parameter, then construct // each parameter @@ -2221,10 +2221,10 @@ TIntermTyped* TParseContext::addConstructor(TIntermNode* node, const TType& type else newNode = constructBuiltIn(type, op, *p, node->getLoc(), true); - if (newNode) { - p = sequenceVector.erase(p); - p = sequenceVector.insert(p, newNode); - } + if (newNode) + *p = newNode; + else + return 0; } TIntermTyped* constructor = intermediate.setAggregateOperator(aggrNode, op, type, loc); @@ -2700,8 +2700,8 @@ TIntermTyped* TParseContext::addConstArrayNode(int index, TIntermTyped* node, TS TIntermTyped* typedNode; TIntermConstantUnion* tempConstantNode = node->getAsConstantUnion(); TType arrayElementType; - arrayElementType.shallowCopy(node->getType()); - arrayElementType.dereference(); // TODO: arrays of arrays: shallow copy won't work if sharing same array structure and then doing a dereference + arrayElementType.shallowCopy(node->getType()); // TODO: arrays of arrays: combine this with deref. + arrayElementType.dereference(); if (index >= node->getType().getArraySize() || index < 0) { error(loc, "", "[", "array index '%d' out of range", index); diff --git a/glslang/MachineIndependent/SymbolTable.cpp b/glslang/MachineIndependent/SymbolTable.cpp index ee964dea..a80c6c55 100644 --- a/glslang/MachineIndependent/SymbolTable.cpp +++ b/glslang/MachineIndependent/SymbolTable.cpp @@ -226,9 +226,9 @@ TSymbol::TSymbol(const TSymbol& copyOf) writable = true; } -TVariable::TVariable(const TVariable& copyOf, TStructureMap& remapper) : TSymbol(copyOf) +TVariable::TVariable(const TVariable& copyOf) : TSymbol(copyOf) { - type.deepCopy(copyOf.type, remapper); + type.deepCopy(copyOf.type); userType = copyOf.userType; if (! copyOf.unionArray.empty()) { @@ -240,35 +240,35 @@ TVariable::TVariable(const TVariable& copyOf, TStructureMap& remapper) : TSymbol } } -TVariable* TVariable::clone(TStructureMap& remapper) +TVariable* TVariable::clone() { - TVariable *variable = new TVariable(*this, remapper); + TVariable *variable = new TVariable(*this); return variable; } -TFunction::TFunction(const TFunction& copyOf, const TStructureMap& remapper) : TSymbol(copyOf) +TFunction::TFunction(const TFunction& copyOf) : TSymbol(copyOf) { for (unsigned int i = 0; i < copyOf.parameters.size(); ++i) { TParameter param; parameters.push_back(param); - parameters.back().copyParam(copyOf.parameters[i], remapper); + parameters.back().copyParam(copyOf.parameters[i]); } - returnType.deepCopy(copyOf.returnType, remapper); + returnType.deepCopy(copyOf.returnType); mangledName = copyOf.mangledName; op = copyOf.op; defined = copyOf.defined; } -TFunction* TFunction::clone(TStructureMap& remapper) +TFunction* TFunction::clone() { - TFunction *function = new TFunction(*this, remapper); + TFunction *function = new TFunction(*this); return function; } -TAnonMember* TAnonMember::clone(TStructureMap& remapper) +TAnonMember* TAnonMember::clone() { // need to implement this once built-in symbols include interface blocks assert(0); @@ -276,13 +276,13 @@ TAnonMember* TAnonMember::clone(TStructureMap& remapper) return 0; } -TSymbolTableLevel* TSymbolTableLevel::clone(TStructureMap& remapper) +TSymbolTableLevel* TSymbolTableLevel::clone() { TSymbolTableLevel *symTableLevel = new TSymbolTableLevel(); symTableLevel->anonId = anonId; tLevel::iterator iter; for (iter = level.begin(); iter != level.end(); ++iter) - symTableLevel->insert(*iter->second->clone(remapper)); + symTableLevel->insert(*iter->second->clone()); return symTableLevel; } @@ -291,11 +291,10 @@ void TSymbolTable::copyTable(const TSymbolTable& copyOf) { assert(adoptedLevels == copyOf.adoptedLevels); - TStructureMap remapper; uniqueId = copyOf.uniqueId; noBuiltInRedeclarations = copyOf.noBuiltInRedeclarations; for (unsigned int i = copyOf.adoptedLevels; i < copyOf.table.size(); ++i) - table.push_back(copyOf.table[i]->clone(remapper)); + table.push_back(copyOf.table[i]->clone()); } } // end namespace glslang diff --git a/glslang/MachineIndependent/SymbolTable.h b/glslang/MachineIndependent/SymbolTable.h index d3831bba..50bb1052 100644 --- a/glslang/MachineIndependent/SymbolTable.h +++ b/glslang/MachineIndependent/SymbolTable.h @@ -81,7 +81,7 @@ class TSymbol { public: POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) explicit TSymbol(const TString *n) : name(n), writable(true) { } - virtual TSymbol* clone(TStructureMap& remapper) = 0; + virtual TSymbol* clone() = 0; virtual ~TSymbol() { } const TString& getName() const { return *name; } @@ -126,7 +126,7 @@ protected: class TVariable : public TSymbol { public: TVariable(const TString *name, const TType& t, bool uT = false ) : TSymbol(name), userType(uT) { type.shallowCopy(t); } - virtual TVariable* clone(TStructureMap& remapper); + virtual TVariable* clone(); virtual ~TVariable() { } virtual TVariable* getAsVariable() { return this; } @@ -142,7 +142,6 @@ public: protected: explicit TVariable(const TVariable&); - TVariable(const TVariable&, TStructureMap& remapper); TVariable& operator=(const TVariable&); TType type; @@ -159,13 +158,13 @@ protected: struct TParameter { TString *name; TType* type; - void copyParam(const TParameter& param, const TStructureMap& remapper) + void copyParam(const TParameter& param) { if (param.name) name = NewPoolTString(param.name->c_str()); else name = 0; - type = param.type->clone(remapper); + type = param.type->clone(); } }; @@ -183,7 +182,7 @@ public: mangledName(*name + '('), op(tOp), defined(false) { returnType.shallowCopy(retType); } - virtual TFunction* clone(TStructureMap& remapper); + virtual TFunction* clone(); virtual ~TFunction(); virtual TFunction* getAsFunction() { return this; } @@ -210,8 +209,7 @@ public: virtual void dump(TInfoSink &infoSink) const; protected: - explicit TFunction(TFunction&); - TFunction(const TFunction&, const TStructureMap& remapper); + explicit TFunction(const TFunction&); TFunction& operator=(TFunction&); typedef TVector TParamList; @@ -225,7 +223,7 @@ protected: class TAnonMember : public TSymbol { public: TAnonMember(const TString* n, unsigned int m, TSymbol& a) : TSymbol(n), anonContainer(a), memberNumber(m) { } - virtual TAnonMember* clone(TStructureMap& remapper); + virtual TAnonMember* clone(); virtual ~TAnonMember() { } const TAnonMember* getAsAnonMember() const { return this; } @@ -346,7 +344,7 @@ public: void relateToOperator(const char* name, TOperator op); void dump(TInfoSink &infoSink) const; - TSymbolTableLevel* clone(TStructureMap& remapper); + TSymbolTableLevel* clone(); void readOnly(); protected: @@ -445,7 +443,7 @@ public: // TVariable* copyUp(TVariable* shared) { - TVariable* variable = shared->clone(remapper); + TVariable* variable = shared->clone(); variable->setUniqueId(shared->getUniqueId()); table[currentLevel()]->insert(*variable); @@ -497,7 +495,6 @@ protected: int uniqueId; // for unique identification in code generation bool noBuiltInRedeclarations; unsigned int adoptedLevels; - TStructureMap remapper; // for now, dummy for copyUp(), which is not yet used for structures }; } // end namespace glslang