From 4605e2ed2b2b1acbe157d365c3c528367b8b168f Mon Sep 17 00:00:00 2001 From: Jeff Bolz Date: Tue, 19 Feb 2019 13:10:32 -0600 Subject: [PATCH] Implement GL_NV_cooperative_matrix --- SPIRV/GLSL.ext.NV.h | 3 + SPIRV/GlslangToSpv.cpp | 149 +- SPIRV/SpvBuilder.cpp | 60 +- SPIRV/SpvBuilder.h | 10 +- SPIRV/doc.cpp | 38 + SPIRV/spirv.hpp | 6 + SPIRV/spvIR.h | 1 + Test/baseResults/420.vert.out | 4 +- Test/baseResults/constErrors.frag.out | 6 +- Test/baseResults/negativeArraySize.comp.out | 2 +- Test/baseResults/spv.1.3.coopmat.comp.out | 95 + Test/baseResults/spv.coopmat.comp.out | 375 + Test/baseResults/spv.coopmat_Error.comp.out | 35 + Test/baseResults/vulkan.vert.out | 5 +- Test/spv.1.3.coopmat.comp | 28 + Test/spv.coopmat.comp | 115 + Test/spv.coopmat_Error.comp | 76 + Test/vulkan.vert | 6 +- glslang/Include/Types.h | 122 +- glslang/Include/arrays.h | 8 +- glslang/Include/intermediate.h | 5 + glslang/MachineIndependent/Constant.cpp | 4 +- glslang/MachineIndependent/Initialize.cpp | 36 + glslang/MachineIndependent/Intermediate.cpp | 49 +- glslang/MachineIndependent/ParseHelper.cpp | 138 +- glslang/MachineIndependent/ParseHelper.h | 2 +- glslang/MachineIndependent/Scan.cpp | 9 + glslang/MachineIndependent/Versions.cpp | 12 + glslang/MachineIndependent/Versions.h | 2 + glslang/MachineIndependent/glslang.y | 58 +- glslang/MachineIndependent/glslang_tab.cpp | 7898 +++++++++-------- glslang/MachineIndependent/glslang_tab.cpp.h | 462 +- glslang/MachineIndependent/intermOut.cpp | 5 + .../MachineIndependent/localintermediate.h | 9 + glslang/MachineIndependent/parseVersions.h | 1 + gtests/Spv.FromFile.cpp | 3 + known_good.json | 4 +- 37 files changed, 5630 insertions(+), 4211 deletions(-) mode change 100755 => 100644 SPIRV/GlslangToSpv.cpp mode change 100755 => 100644 SPIRV/SpvBuilder.cpp mode change 100755 => 100644 SPIRV/SpvBuilder.h create mode 100644 Test/baseResults/spv.1.3.coopmat.comp.out create mode 100644 Test/baseResults/spv.coopmat.comp.out create mode 100644 Test/baseResults/spv.coopmat_Error.comp.out create mode 100644 Test/spv.1.3.coopmat.comp create mode 100644 Test/spv.coopmat.comp create mode 100644 Test/spv.coopmat_Error.comp mode change 100755 => 100644 glslang/MachineIndependent/Constant.cpp mode change 100755 => 100644 glslang/MachineIndependent/Initialize.cpp mode change 100755 => 100644 glslang/MachineIndependent/Intermediate.cpp mode change 100755 => 100644 glslang/MachineIndependent/ParseHelper.cpp mode change 100755 => 100644 glslang/MachineIndependent/ParseHelper.h mode change 100755 => 100644 glslang/MachineIndependent/Versions.cpp mode change 100755 => 100644 glslang/MachineIndependent/glslang.y diff --git a/SPIRV/GLSL.ext.NV.h b/SPIRV/GLSL.ext.NV.h index 102d645c..ede2c570 100644 --- a/SPIRV/GLSL.ext.NV.h +++ b/SPIRV/GLSL.ext.NV.h @@ -72,4 +72,7 @@ const char* const E_SPV_NV_ray_tracing = "SPV_NV_ray_tracing"; //SPV_NV_shading_rate const char* const E_SPV_NV_shading_rate = "SPV_NV_shading_rate"; +//SPV_NV_cooperative_matrix +const char* const E_SPV_NV_cooperative_matrix = "SPV_NV_cooperative_matrix"; + #endif // #ifndef GLSLextNV_H diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp old mode 100755 new mode 100644 index 9bf37045..2ddece12 --- a/SPIRV/GlslangToSpv.cpp +++ b/SPIRV/GlslangToSpv.cpp @@ -1330,6 +1330,10 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion, const gl } builder.setMemoryModel(addressingModel, memoryModel); + if (glslangIntermediate->usingVariablePointers()) { + builder.addCapability(spv::CapabilityVariablePointers); + } + shaderEntry = builder.makeEntryPoint(glslangIntermediate->getEntryPointName().c_str()); entryPoint = builder.addEntryPoint(executionModel, shaderEntry, glslangIntermediate->getEntryPointName().c_str()); @@ -1870,16 +1874,31 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI // So, this has to be block.lastMember.length(). // SPV wants "block" and member number as the operands, go get them. - glslang::TIntermTyped* block = node->getOperand()->getAsBinaryNode()->getLeft(); - block->traverse(this); - unsigned int member = node->getOperand()->getAsBinaryNode()->getRight()->getAsConstantUnion()->getConstArray()[0].getUConst(); - spv::Id length = builder.createArrayLength(builder.accessChainGetLValue(), member); + spv::Id length; + if (node->getOperand()->getType().isCoopMat()) { + spec_constant_op_mode_setter.turnOnSpecConstantOpMode(); + + spv::Id typeId = convertGlslangToSpvType(node->getOperand()->getType()); + assert(builder.isCooperativeMatrixType(typeId)); + + length = builder.createCooperativeMatrixLength(typeId); + } else { + glslang::TIntermTyped* block = node->getOperand()->getAsBinaryNode()->getLeft(); + block->traverse(this); + unsigned int member = node->getOperand()->getAsBinaryNode()->getRight()->getAsConstantUnion()->getConstArray()[0].getUConst(); + length = builder.createArrayLength(builder.accessChainGetLValue(), member); + } // GLSL semantics say the result of .length() is an int, while SPIR-V says // signedness must be 0. So, convert from SPIR-V unsigned back to GLSL's // AST expectation of a signed result. - if (glslangIntermediate->getSource() == glslang::EShSourceGlsl) - length = builder.createUnaryOp(spv::OpBitcast, builder.makeIntType(32), length); + if (glslangIntermediate->getSource() == glslang::EShSourceGlsl) { + if (builder.isInSpecConstCodeGenMode()) { + length = builder.createBinOp(spv::OpIAdd, builder.makeIntType(32), length, builder.makeIntConstant(0)); + } else { + length = builder.createUnaryOp(spv::OpBitcast, builder.makeIntType(32), length); + } + } builder.clearAccessChain(); builder.setAccessChainRValue(length); @@ -2222,6 +2241,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt case glslang::EOpConstructStruct: case glslang::EOpConstructTextureSampler: case glslang::EOpConstructReference: + case glslang::EOpConstructCooperativeMatrix: { builder.setLine(node->getLoc().line, node->getLoc().getFilename()); std::vector arguments; @@ -2229,7 +2249,9 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt spv::Id constructed; if (node->getOp() == glslang::EOpConstructTextureSampler) constructed = builder.createOp(spv::OpSampledImage, resultType(), arguments); - else if (node->getOp() == glslang::EOpConstructStruct || node->getType().isArray()) { + else if (node->getOp() == glslang::EOpConstructStruct || + node->getOp() == glslang::EOpConstructCooperativeMatrix || + node->getType().isArray()) { std::vector constituents; for (int c = 0; c < (int)arguments.size(); ++c) constituents.push_back(arguments[c]); @@ -2347,6 +2369,10 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt noReturnValue = true; break; #endif + case glslang::EOpCooperativeMatrixLoad: + case glslang::EOpCooperativeMatrixStore: + noReturnValue = true; + break; default: break; @@ -2389,6 +2415,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt // glslang::TIntermSequence& glslangOperands = node->getSequence(); std::vector operands; + std::vector memoryAccessOperands; for (int arg = 0; arg < (int)glslangOperands.size(); ++arg) { // special case l-value operands; there are just a few bool lvalue = false; @@ -2445,6 +2472,14 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt if (arg >= 2) lvalue = true; break; + case glslang::EOpCooperativeMatrixLoad: + if (arg == 0 || arg == 1) + lvalue = true; + break; + case glslang::EOpCooperativeMatrixStore: + if (arg == 1) + lvalue = true; + break; default: break; } @@ -2453,6 +2488,50 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt glslangOperands[0]->getAsBinaryNode()->getLeft()->traverse(this); else glslangOperands[arg]->traverse(this); + + if (node->getOp() == glslang::EOpCooperativeMatrixLoad || + node->getOp() == glslang::EOpCooperativeMatrixStore) { + + if (arg == 1) { + // fold "element" parameter into the access chain + spv::Builder::AccessChain save = builder.getAccessChain(); + builder.clearAccessChain(); + glslangOperands[2]->traverse(this); + + spv::Id elementId = accessChainLoad(glslangOperands[2]->getAsTyped()->getType()); + + builder.setAccessChain(save); + + // Point to the first element of the array. + builder.accessChainPush(elementId, TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType()), + getBufferReferenceAlignment(glslangOperands[arg]->getAsTyped()->getType())); + + spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags; + unsigned int alignment = builder.getAccessChain().alignment; + + int memoryAccess = TranslateMemoryAccess(coherentFlags); + if (node->getOp() == glslang::EOpCooperativeMatrixLoad) + memoryAccess &= ~spv::MemoryAccessMakePointerAvailableKHRMask; + if (node->getOp() == glslang::EOpCooperativeMatrixStore) + memoryAccess &= ~spv::MemoryAccessMakePointerVisibleKHRMask; + if (builder.getStorageClass(builder.getAccessChain().base) == spv::StorageClassPhysicalStorageBufferEXT) { + memoryAccess = (spv::MemoryAccessMask)(memoryAccess | spv::MemoryAccessAlignedMask); + } + + memoryAccessOperands.push_back(spv::IdImmediate(false, memoryAccess)); + + if (memoryAccess & spv::MemoryAccessAlignedMask) { + memoryAccessOperands.push_back(spv::IdImmediate(false, alignment)); + } + + if (memoryAccess & (spv::MemoryAccessMakePointerAvailableKHRMask | spv::MemoryAccessMakePointerVisibleKHRMask)) { + memoryAccessOperands.push_back(spv::IdImmediate(true, builder.makeUintConstant(TranslateMemoryScope(coherentFlags)))); + } + } else if (arg == 2) { + continue; + } + } + if (lvalue) operands.push_back(builder.accessChainGetLValue()); else { @@ -2462,7 +2541,33 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt } builder.setLine(node->getLoc().line, node->getLoc().getFilename()); - if (atomic) { + if (node->getOp() == glslang::EOpCooperativeMatrixLoad) { + std::vector idImmOps; + + idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf + idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride + idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor + idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end()); + // get the pointee type + spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0])); + assert(builder.isCooperativeMatrixType(typeId)); + // do the op + spv::Id result = builder.createOp(spv::OpCooperativeMatrixLoadNV, typeId, idImmOps); + // store the result to the pointer (out param 'm') + builder.createStore(result, operands[0]); + result = 0; + } else if (node->getOp() == glslang::EOpCooperativeMatrixStore) { + std::vector idImmOps; + + idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf + idImmOps.push_back(spv::IdImmediate(true, operands[0])); // object + idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride + idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor + idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end()); + + builder.createNoResultOp(spv::OpCooperativeMatrixStoreNV, idImmOps); + result = 0; + } else if (atomic) { // Handle all atomics result = createAtomicOperation(node->getOp(), precision, resultType(), operands, node->getBasicType()); } else { @@ -3090,6 +3195,19 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty spvType = builder.makeVectorType(spvType, type.getVectorSize()); } + if (type.isCoopMat()) { + builder.addCapability(spv::CapabilityCooperativeMatrixNV); + builder.addExtension(spv::E_SPV_NV_cooperative_matrix); + if (type.getBasicType() == glslang::EbtFloat16) + builder.addCapability(spv::CapabilityFloat16); + + spv::Id scope = makeArraySizeId(*type.getTypeParameters(), 1); + spv::Id rows = makeArraySizeId(*type.getTypeParameters(), 2); + spv::Id cols = makeArraySizeId(*type.getTypeParameters(), 3); + + spvType = builder.makeCooperativeMatrixType(spvType, scope, rows, cols); + } + if (type.isArray()) { int stride = 0; // keep this 0 unless doing an explicit layout; 0 will mean no decoration, no stride @@ -4847,7 +4965,8 @@ spv::Id TGlslangToSpvTraverser::createBinaryOperation(glslang::TOperator op, OpD // handle mapped binary operations (should be non-comparison) if (binOp != spv::OpNop) { assert(comparison == false); - if (builder.isMatrix(left) || builder.isMatrix(right)) + if (builder.isMatrix(left) || builder.isMatrix(right) || + builder.isCooperativeMatrix(left) || builder.isCooperativeMatrix(right)) return createBinaryMatrixOperation(binOp, decorations, typeId, left, right); // No matrix involved; make both operands be the same number of components, if needed @@ -4968,7 +5087,7 @@ spv::Id TGlslangToSpvTraverser::createBinaryMatrixOperation(spv::Op op, OpDecora firstClass = false; break; case spv::OpMatrixTimesScalar: - if (builder.isMatrix(right)) + if (builder.isMatrix(right) || builder.isCooperativeMatrix(right)) std::swap(left, right); assert(builder.isScalar(right)); break; @@ -4989,6 +5108,9 @@ spv::Id TGlslangToSpvTraverser::createBinaryMatrixOperation(spv::Op op, OpDecora break; } + if (builder.isCooperativeMatrix(left) || builder.isCooperativeMatrix(right)) + firstClass = true; + if (firstClass) { spv::Id result = builder.createBinOp(op, typeId, left, right); builder.addDecoration(result, decorations.noContraction); @@ -7030,6 +7152,10 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv:: builder.createNoResultOp(spv::OpWritePackedPrimitiveIndices4x8NV, operands); return 0; #endif + case glslang::EOpCooperativeMatrixMulAdd: + opCode = spv::OpCooperativeMatrixMulAddNV; + break; + default: return 0; } @@ -7486,6 +7612,9 @@ spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glsla glslang::TType vectorType(glslangType, 0); for (int col = 0; col < glslangType.getMatrixCols(); ++col) spvConsts.push_back(createSpvConstantFromConstUnionArray(vectorType, consts, nextConst, false)); + } else if (glslangType.isCoopMat()) { + glslang::TType componentType(glslangType.getBasicType()); + spvConsts.push_back(createSpvConstantFromConstUnionArray(componentType, consts, nextConst, false)); } else if (glslangType.isStruct()) { glslang::TVector::const_iterator iter; for (iter = glslangType.getStruct()->begin(); iter != glslangType.getStruct()->end(); ++iter) diff --git a/SPIRV/SpvBuilder.cpp b/SPIRV/SpvBuilder.cpp old mode 100755 new mode 100644 index 8355d833..138c41c5 --- a/SPIRV/SpvBuilder.cpp +++ b/SPIRV/SpvBuilder.cpp @@ -388,6 +388,33 @@ Id Builder::makeMatrixType(Id component, int cols, int rows) return type->getResultId(); } +Id Builder::makeCooperativeMatrixType(Id component, Id scope, Id rows, Id cols) +{ + // try to find it + Instruction* type; + for (int t = 0; t < (int)groupedTypes[OpTypeCooperativeMatrixNV].size(); ++t) { + type = groupedTypes[OpTypeCooperativeMatrixNV][t]; + if (type->getIdOperand(0) == component && + type->getIdOperand(1) == scope && + type->getIdOperand(2) == rows && + type->getIdOperand(3) == cols) + return type->getResultId(); + } + + // not found, make it + type = new Instruction(getUniqueId(), NoType, OpTypeCooperativeMatrixNV); + type->addIdOperand(component); + type->addIdOperand(scope); + type->addIdOperand(rows); + type->addIdOperand(cols); + groupedTypes[OpTypeCooperativeMatrixNV].push_back(type); + constantsTypesGlobals.push_back(std::unique_ptr(type)); + module.mapInstruction(type); + + return type->getResultId(); +} + + // TODO: performance: track arrays per stride // If a stride is supplied (non-zero) make an array. // If no stride (0), reuse previous array types. @@ -623,6 +650,9 @@ int Builder::getNumTypeConstituents(Id typeId) const } case OpTypeStruct: return instr->getNumOperands(); + case OpTypeCooperativeMatrixNV: + // has only one constituent when used with OpCompositeConstruct. + return 1; default: assert(0); return 1; @@ -669,6 +699,7 @@ Id Builder::getContainedTypeId(Id typeId, int member) const case OpTypeMatrix: case OpTypeArray: case OpTypeRuntimeArray: + case OpTypeCooperativeMatrixNV: return instr->getIdOperand(0); case OpTypePointer: return instr->getIdOperand(1); @@ -981,15 +1012,14 @@ Id Builder::makeFpConstant(Id type, double d, bool specConstant) return NoResult; } -Id Builder::findCompositeConstant(Op typeClass, const std::vector& comps) +Id Builder::findCompositeConstant(Op typeClass, Id typeId, const std::vector& comps) { Instruction* constant = 0; bool found = false; for (int i = 0; i < (int)groupedConstants[typeClass].size(); ++i) { constant = groupedConstants[typeClass][i]; - // same shape? - if (constant->getNumOperands() != (int)comps.size()) + if (constant->getTypeId() != typeId) continue; // same contents? @@ -1044,8 +1074,9 @@ Id Builder::makeCompositeConstant(Id typeId, const std::vector& members, boo case OpTypeVector: case OpTypeArray: case OpTypeMatrix: + case OpTypeCooperativeMatrixNV: if (! specConstant) { - Id existing = findCompositeConstant(typeClass, members); + Id existing = findCompositeConstant(typeClass, typeId, members); if (existing) return existing; } @@ -1408,6 +1439,23 @@ Id Builder::createArrayLength(Id base, unsigned int member) return length->getResultId(); } +Id Builder::createCooperativeMatrixLength(Id type) +{ + spv::Id intType = makeUintType(32); + + // Generate code for spec constants if in spec constant operation + // generation mode. + if (generatingOpCodeForSpecConst) { + return createSpecConstantOp(OpCooperativeMatrixLengthNV, intType, std::vector(1, type), std::vector()); + } + + Instruction* length = new Instruction(getUniqueId(), intType, OpCooperativeMatrixLengthNV); + length->addIdOperand(type); + buildPoint->addInstruction(std::unique_ptr(length)); + + return length->getResultId(); +} + Id Builder::createCompositeExtract(Id composite, Id typeId, unsigned index) { // Generate code for spec constants if in spec constant operation @@ -2598,9 +2646,9 @@ Id Builder::accessChainLoad(Decoration precision, Decoration nonUniform, Id resu } } - if (constant) + if (constant) { id = createCompositeExtract(accessChain.base, swizzleBase, indexes); - else { + } else { // make a new function variable for this r-value Id lValue = createVariable(StorageClassFunction, getTypeId(accessChain.base), "indexable"); diff --git a/SPIRV/SpvBuilder.h b/SPIRV/SpvBuilder.h old mode 100755 new mode 100644 index edeac1b6..52f7fba7 --- a/SPIRV/SpvBuilder.h +++ b/SPIRV/SpvBuilder.h @@ -155,6 +155,7 @@ public: Id makeImageType(Id sampledType, Dim, bool depth, bool arrayed, bool ms, unsigned sampled, ImageFormat format); Id makeSamplerType(); Id makeSampledImageType(Id imageType); + Id makeCooperativeMatrixType(Id component, Id scope, Id rows, Id cols); // accelerationStructureNV type Id makeAccelerationStructureNVType(); @@ -178,6 +179,7 @@ public: bool isScalar(Id resultId) const { return isScalarType(getTypeId(resultId)); } bool isVector(Id resultId) const { return isVectorType(getTypeId(resultId)); } bool isMatrix(Id resultId) const { return isMatrixType(getTypeId(resultId)); } + bool isCooperativeMatrix(Id resultId)const { return isCooperativeMatrixType(getTypeId(resultId)); } bool isAggregate(Id resultId) const { return isAggregateType(getTypeId(resultId)); } bool isSampledImage(Id resultId) const { return isSampledImageType(getTypeId(resultId)); } @@ -191,7 +193,8 @@ public: bool isMatrixType(Id typeId) const { return getTypeClass(typeId) == OpTypeMatrix; } bool isStructType(Id typeId) const { return getTypeClass(typeId) == OpTypeStruct; } bool isArrayType(Id typeId) const { return getTypeClass(typeId) == OpTypeArray; } - bool isAggregateType(Id typeId) const { return isArrayType(typeId) || isStructType(typeId); } + bool isCooperativeMatrixType(Id typeId)const { return getTypeClass(typeId) == OpTypeCooperativeMatrixNV; } + bool isAggregateType(Id typeId) const { return isArrayType(typeId) || isStructType(typeId) || isCooperativeMatrixType(typeId); } bool isImageType(Id typeId) const { return getTypeClass(typeId) == OpTypeImage; } bool isSamplerType(Id typeId) const { return getTypeClass(typeId) == OpTypeSampler; } bool isSampledImageType(Id typeId) const { return getTypeClass(typeId) == OpTypeSampledImage; } @@ -314,6 +317,9 @@ public: // Create an OpArrayLength instruction Id createArrayLength(Id base, unsigned int member); + // Create an OpCooperativeMatrixLengthNV instruction + Id createCooperativeMatrixLength(Id type); + // Create an OpCompositeExtract instruction Id createCompositeExtract(Id composite, Id typeId, unsigned index); Id createCompositeExtract(Id composite, Id typeId, const std::vector& indexes); @@ -670,7 +676,7 @@ public: Id makeInt64Constant(Id typeId, unsigned long long value, bool specConstant); Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned value); Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned v1, unsigned v2); - Id findCompositeConstant(Op typeClass, const std::vector& comps); + Id findCompositeConstant(Op typeClass, Id typeId, const std::vector& comps); Id findStructConstant(Id typeId, const std::vector& comps); Id collapseAccessChain(); void remapDynamicSwizzle(); diff --git a/SPIRV/doc.cpp b/SPIRV/doc.cpp index bd6df107..76e1df8d 100644 --- a/SPIRV/doc.cpp +++ b/SPIRV/doc.cpp @@ -930,6 +930,10 @@ const char* CapabilityString(int info) case CapabilityPhysicalStorageBufferAddressesEXT: return "CapabilityPhysicalStorageBufferAddressesEXT"; + case CapabilityVariablePointers: return "CapabilityVariablePointers"; + + case CapabilityCooperativeMatrixNV: return "CapabilityCooperativeMatrixNV"; + default: return "Bad"; } } @@ -1333,6 +1337,12 @@ const char* OpcodeString(int op) case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV"; #endif + case OpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV"; + case OpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV"; + case OpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV"; + case OpCooperativeMatrixMulAddNV: return "OpCooperativeMatrixMulAddNV"; + case OpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV"; + default: return "Bad"; } @@ -1444,6 +1454,8 @@ void Parameterize() InstructionDesc[OpGroupWaitEvents].setResultAndType(false, false); InstructionDesc[OpAtomicFlagClear].setResultAndType(false, false); InstructionDesc[OpModuleProcessed].setResultAndType(false, false); + InstructionDesc[OpTypeCooperativeMatrixNV].setResultAndType(true, false); + InstructionDesc[OpCooperativeMatrixStoreNV].setResultAndType(false, false); // Specific additional context-dependent operands @@ -2714,6 +2726,32 @@ void Parameterize() InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Index Offset'"); InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Packed Indices'"); #endif + + InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Component Type'"); + InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Scope'"); + InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Rows'"); + InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Columns'"); + + InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Pointer'"); + InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Stride'"); + InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Column Major'"); + InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandMemoryAccess, "'Memory Access'"); + InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandLiteralNumber, "", true); + InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "", true); + + InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Pointer'"); + InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Object'"); + InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Stride'"); + InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Column Major'"); + InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandMemoryAccess, "'Memory Access'"); + InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandLiteralNumber, "", true); + InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "", true); + + InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'A'"); + InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'B'"); + InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'C'"); + + InstructionDesc[OpCooperativeMatrixLengthNV].operands.push(OperandId, "'Type'"); } }; // end spv namespace diff --git a/SPIRV/spirv.hpp b/SPIRV/spirv.hpp index 44d06168..523f7bba 100644 --- a/SPIRV/spirv.hpp +++ b/SPIRV/spirv.hpp @@ -811,6 +811,7 @@ enum Capability { CapabilityVulkanMemoryModelDeviceScopeKHR = 5346, CapabilityPhysicalStorageBufferAddressesEXT = 5347, CapabilityComputeDerivativeGroupLinearNV = 5350, + CapabilityCooperativeMatrixNV = 5357, CapabilitySubgroupShuffleINTEL = 5568, CapabilitySubgroupBufferBlockIOINTEL = 5569, CapabilitySubgroupImageBlockIOINTEL = 5570, @@ -1183,6 +1184,11 @@ enum Op { OpTraceNV = 5337, OpTypeAccelerationStructureNV = 5341, OpExecuteCallableNV = 5344, + OpTypeCooperativeMatrixNV = 5358, + OpCooperativeMatrixLoadNV = 5359, + OpCooperativeMatrixStoreNV = 5360, + OpCooperativeMatrixMulAddNV = 5361, + OpCooperativeMatrixLengthNV = 5362, OpSubgroupShuffleINTEL = 5571, OpSubgroupShuffleDownINTEL = 5572, OpSubgroupShuffleUpINTEL = 5573, diff --git a/SPIRV/spvIR.h b/SPIRV/spvIR.h index 8c2d0b6f..b3cd0b06 100755 --- a/SPIRV/spvIR.h +++ b/SPIRV/spvIR.h @@ -83,6 +83,7 @@ const MemorySemanticsMask MemorySemanticsAllMemory = struct IdImmediate { bool isId; // true if word is an Id, false if word is an immediate unsigned word; + IdImmediate(bool i, unsigned w) : isId(i), word(w) {} }; // diff --git a/Test/baseResults/420.vert.out b/Test/baseResults/420.vert.out index 22577ab0..740c8fe7 100644 --- a/Test/baseResults/420.vert.out +++ b/Test/baseResults/420.vert.out @@ -8,7 +8,7 @@ ERROR: 0:12: '' : can only have one auxiliary qualifier (centroid, patch, and sa ERROR: 0:13: 'uniform' : too many storage qualifiers ERROR: 0:18: '=' : global const initializers must be constant ' const int' ERROR: 0:20: 'const' : no qualifiers allowed for function return -ERROR: 0:27: '' : array size must be a constant integer expression +ERROR: 0:27: '' : array size must be a constant integer expression ERROR: 0:38: 'j' : undeclared identifier ERROR: 0:38: '=' : cannot convert from ' temp float' to ' temp int' ERROR: 0:39: 'k' : undeclared identifier @@ -31,7 +31,7 @@ ERROR: 0:85: 'patch' : not supported in this stage: vertex ERROR: 0:85: '' : vertex input cannot be further qualified ERROR: 0:86: 'patch' : not supported in this stage: vertex ERROR: 0:100: '=' : global const initializers must be constant ' const int' -ERROR: 0:101: '' : array size must be a constant integer expression +ERROR: 0:101: '' : array size must be a constant integer expression ERROR: 0:107: 'image variables not declared 'writeonly' and without a format layout qualifier' : not supported for this version or the enabled extensions ERROR: 0:114: 'imageAtomicMin' : only supported on image with format r32i or r32ui ERROR: 0:115: 'imageAtomicMax' : no matching overloaded function found diff --git a/Test/baseResults/constErrors.frag.out b/Test/baseResults/constErrors.frag.out index 0b2dc62f..21774849 100644 --- a/Test/baseResults/constErrors.frag.out +++ b/Test/baseResults/constErrors.frag.out @@ -1,8 +1,8 @@ constErrors.frag ERROR: 0:14: 'non-constant initializer' : not supported for this version or the enabled extensions -ERROR: 0:17: '' : array size must be a constant integer expression -ERROR: 0:18: '' : array size must be a constant integer expression -ERROR: 0:19: '' : array size must be a constant integer expression +ERROR: 0:17: '' : array size must be a constant integer expression +ERROR: 0:18: '' : array size must be a constant integer expression +ERROR: 0:19: '' : array size must be a constant integer expression ERROR: 0:27: '=' : global const initializers must be constant ' const structure{ global 3-component vector of float v3, global 2-component vector of int iv2}' ERROR: 0:33: '=' : global const initializers must be constant ' const structure{ global 3-component vector of float v3, global 2-component vector of int iv2, global 2X4 matrix of float m}' ERROR: 6 compilation errors. No code generated. diff --git a/Test/baseResults/negativeArraySize.comp.out b/Test/baseResults/negativeArraySize.comp.out index 0a5ba310..5ae83dca 100644 --- a/Test/baseResults/negativeArraySize.comp.out +++ b/Test/baseResults/negativeArraySize.comp.out @@ -1,5 +1,5 @@ negativeArraySize.comp -ERROR: 0:9: '' : array size must be a positive integer +ERROR: 0:9: '' : array size must be a positive integer ERROR: 1 compilation errors. No code generated. diff --git a/Test/baseResults/spv.1.3.coopmat.comp.out b/Test/baseResults/spv.1.3.coopmat.comp.out new file mode 100644 index 00000000..aa1b9491 --- /dev/null +++ b/Test/baseResults/spv.1.3.coopmat.comp.out @@ -0,0 +1,95 @@ +spv.1.3.coopmat.comp +// Module Version 10300 +// Generated by (magic number): 80007 +// Id's are bound by 52 + + Capability Shader + Capability CapabilityVariablePointers + Capability CapabilityVulkanMemoryModelKHR + Capability CapabilityCooperativeMatrixNV + Extension "SPV_KHR_vulkan_memory_model" + Extension "SPV_NV_cooperative_matrix" + 1: ExtInstImport "GLSL.std.450" + MemoryModel Logical VulkanKHR + EntryPoint GLCompute 4 "main" + ExecutionMode 4 LocalSize 64 1 1 + Source GLSL 450 + SourceExtension "GL_EXT_shader_explicit_arithmetic_types_float16" + SourceExtension "GL_KHR_memory_scope_semantics" + SourceExtension "GL_NV_cooperative_matrix" + Name 4 "main" + Name 13 "m" + Name 29 "tempArg" + Name 33 "Block" + MemberName 33(Block) 0 "y" + MemberName 33(Block) 1 "x" + Name 35 "block" + Decorate 31 ArrayStride 4 + Decorate 32 ArrayStride 4 + MemberDecorate 33(Block) 0 Offset 0 + MemberDecorate 33(Block) 1 Offset 4194304 + Decorate 33(Block) Block + Decorate 35(block) DescriptorSet 0 + Decorate 35(block) Binding 0 + Decorate 51 BuiltIn WorkgroupSize + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeFloat 32 + 7: TypeInt 32 0 + 8: 7(int) Constant 3 + 9: 7(int) Constant 16 + 10: 7(int) Constant 8 + 11: TypeCooperativeMatrixNV 6(float) 8 9 10 + 12: TypePointer Function 11 + 14: 6(float) Constant 0 + 15: 11 ConstantComposite 14 + 24: 6(float) Constant 1073741824 + 30: 7(int) Constant 1048576 + 31: TypeArray 6(float) 30 + 32: TypeRuntimeArray 6(float) + 33(Block): TypeStruct 31 32 + 34: TypePointer StorageBuffer 33(Block) + 35(block): 34(ptr) Variable StorageBuffer + 36: TypeInt 32 1 + 37: 36(int) Constant 1 + 38: 7(int) Constant 5 + 39: TypePointer StorageBuffer 6(float) + 41: 7(int) Constant 128 + 42: TypeBool + 43: 42(bool) ConstantFalse + 48: TypeVector 7(int) 3 + 49: 7(int) Constant 64 + 50: 7(int) Constant 1 + 51: 48(ivec3) ConstantComposite 49 50 50 + 4(main): 2 Function None 3 + 5: Label + 13(m): 12(ptr) Variable Function + 29(tempArg): 12(ptr) Variable Function + Store 13(m) 15 + 16: 11 Load 13(m) + 17: 11 Load 13(m) + 18: 11 FAdd 16 17 + Store 13(m) 18 + 19: 11 Load 13(m) + 20: 11 Load 13(m) + 21: 11 FSub 19 20 + Store 13(m) 21 + 22: 11 Load 13(m) + 23: 11 FNegate 22 + Store 13(m) 23 + 25: 11 Load 13(m) + 26: 11 MatrixTimesScalar 25 24 + Store 13(m) 26 + 27: 11 Load 13(m) + 28: 11 MatrixTimesScalar 27 24 + Store 13(m) 28 + 40: 39(ptr) AccessChain 35(block) 37 9 + 44: 11 CooperativeMatrixLoadNV 40 41 43 MakePointerVisibleKHR NonPrivatePointerKHR 38 + Store 29(tempArg) 44 + 45: 11 Load 29(tempArg) + Store 13(m) 45 + 46: 11 Load 13(m) + 47: 39(ptr) AccessChain 35(block) 37 9 + CooperativeMatrixStoreNV 47 46 41 43 MakePointerAvailableKHR NonPrivatePointerKHR 38 + Return + FunctionEnd diff --git a/Test/baseResults/spv.coopmat.comp.out b/Test/baseResults/spv.coopmat.comp.out new file mode 100644 index 00000000..5c003841 --- /dev/null +++ b/Test/baseResults/spv.coopmat.comp.out @@ -0,0 +1,375 @@ +spv.coopmat.comp +// Module Version 10000 +// Generated by (magic number): 80007 +// Id's are bound by 228 + + Capability Shader + Capability Float16 + Capability StorageUniformBufferBlock16 + Capability CapabilityVulkanMemoryModelKHR + Capability CapabilityPhysicalStorageBufferAddressesEXT + Capability CapabilityCooperativeMatrixNV + Extension "SPV_EXT_physical_storage_buffer" + Extension "SPV_KHR_16bit_storage" + Extension "SPV_KHR_storage_buffer_storage_class" + Extension "SPV_KHR_vulkan_memory_model" + Extension "SPV_NV_cooperative_matrix" + 1: ExtInstImport "GLSL.std.450" + MemoryModel PhysicalStorageBuffer64EXT VulkanKHR + EntryPoint GLCompute 4 "main" + ExecutionMode 4 LocalSize 64 1 1 + Source GLSL 450 + SourceExtension "GL_EXT_buffer_reference" + SourceExtension "GL_EXT_shader_explicit_arithmetic_types_float16" + SourceExtension "GL_KHR_memory_scope_semantics" + SourceExtension "GL_NV_cooperative_matrix" + Name 4 "main" + Name 14 "f16(f161;" + Name 13 "m" + Name 21 "f32(f1;" + Name 20 "m" + Name 34 "m" + Name 52 "m2" + Name 56 "x" + Name 64 "tempArg" + Name 68 "Block" + MemberName 68(Block) 0 "y" + MemberName 68(Block) 1 "x" + Name 70 "block" + Name 81 "tempArg" + Name 86 "Block16" + MemberName 86(Block16) 0 "y" + MemberName 86(Block16) 1 "x" + MemberName 86(Block16) 2 "b" + Name 89 "Block" + MemberName 89(Block) 0 "y" + MemberName 89(Block) 1 "x" + Name 91 "block16" + Name 98 "tempArg" + Name 111 "D" + Name 112 "A" + Name 114 "B" + Name 116 "C" + Name 120 "l" + Name 124 "Y" + Name 125 "Z" + Name 128 "F" + Name 133 "a" + Name 137 "md1" + Name 148 "mC2" + Name 153 "tempArg" + Name 159 "tempArg" + Name 165 "p1" + Name 166 "param" + Name 169 "p2" + Name 170 "param" + Name 184 "tempArg" + Name 189 "shmatrix" + Name 194 "ms" + Name 201 "mC" + Name 206 "arr" + Name 211 "arr2" + Name 212 "F" + Name 217 "S" + MemberName 217(S) 0 "a" + MemberName 217(S) 1 "b" + MemberName 217(S) 2 "c" + Name 222 "SC" + Name 227 "scm" + Decorate 66 ArrayStride 4 + Decorate 67 ArrayStride 4 + MemberDecorate 68(Block) 0 Offset 0 + MemberDecorate 68(Block) 1 Offset 4194304 + Decorate 68(Block) Block + Decorate 70(block) DescriptorSet 0 + Decorate 70(block) Binding 0 + Decorate 82 ArrayStride 2 + Decorate 84 ArrayStride 2 + MemberDecorate 86(Block16) 0 Offset 0 + MemberDecorate 86(Block16) 1 Offset 2097152 + MemberDecorate 86(Block16) 2 Offset 2097160 + Decorate 86(Block16) Block + Decorate 87 ArrayStride 4 + Decorate 88 ArrayStride 4 + MemberDecorate 89(Block) 0 Offset 0 + MemberDecorate 89(Block) 1 Offset 4194304 + Decorate 89(Block) Block + Decorate 91(block16) DescriptorSet 0 + Decorate 91(block16) Binding 0 + Decorate 124(Y) SpecId 0 + Decorate 200 BuiltIn WorkgroupSize + Decorate 212(F) SpecId 1 + Decorate 222(SC) SpecId 2 + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeFloat 16 + 7: TypeInt 32 0 + 8: 7(int) Constant 3 + 9: 7(int) Constant 8 + 10: TypeCooperativeMatrixNV 6(float16_t) 8 9 9 + 11: TypePointer Function 10 + 12: TypeFunction 10 11(ptr) + 16: TypeFloat 32 + 17: TypeCooperativeMatrixNV 16(float) 8 9 9 + 18: TypePointer Function 17 + 19: TypeFunction 17 18(ptr) + 31: 7(int) Constant 16 + 32: TypeCooperativeMatrixNV 16(float) 8 31 9 + 33: TypePointer Function 32 + 35: 16(float) Constant 0 + 36: 32 ConstantComposite 35 + 45: 16(float) Constant 1073741824 + 50: TypeCooperativeMatrixNV 6(float16_t) 8 31 9 + 51: TypePointer Function 50 + 55: TypePointer Function 16(float) + 57: TypeInt 32 1 + 58: 57(int) Constant 1 + 61: 57(int) Constant 0 + 65: 7(int) Constant 1048576 + 66: TypeArray 16(float) 65 + 67: TypeRuntimeArray 16(float) + 68(Block): TypeStruct 66 67 + 69: TypePointer StorageBuffer 68(Block) + 70(block): 69(ptr) Variable StorageBuffer + 71: 7(int) Constant 5 + 72: TypePointer StorageBuffer 16(float) + 74: 7(int) Constant 128 + 75: TypeBool + 76: 75(bool) ConstantFalse + 82: TypeArray 6(float16_t) 65 + 83: 7(int) Constant 1 + 84: TypeArray 6(float16_t) 83 + TypeForwardPointer 85 PhysicalStorageBufferEXT + 86(Block16): TypeStruct 82 84 85 + 87: TypeArray 16(float) 65 + 88: TypeRuntimeArray 16(float) + 89(Block): TypeStruct 87 88 + 85: TypePointer PhysicalStorageBufferEXT 89(Block) + 90: TypePointer StorageBuffer 86(Block16) + 91(block16): 90(ptr) Variable StorageBuffer + 92: TypePointer StorageBuffer 6(float16_t) + 99: 57(int) Constant 2 + 100: TypePointer StorageBuffer 85(ptr) + 103: TypePointer PhysicalStorageBufferEXT 16(float) + 119: TypePointer Function 57(int) + 121: 7(int) SpecConstantOp 5362 32 + 122: 57(int) SpecConstantOp 128 121 61 + 123: 57(int) Constant 8 + 124(Y): 57(int) SpecConstant 2 + 125(Z): 57(int) SpecConstantOp 132 123 124(Y) + 126: TypeCooperativeMatrixNV 6(float16_t) 8 125(Z) 125(Z) + 127: TypePointer Function 126 + 129:6(float16_t) Constant 0 + 130: 126 ConstantComposite 129 + 131: TypeArray 32 71 + 132: TypePointer Function 131 + 134: 57(int) Constant 3 + 135: 16(float) Constant 1065353216 + 141: 57(int) Constant 1234 + 145: TypeCooperativeMatrixNV 6(float16_t) 8 125(Z) 9 + 146: TypeArray 145 8 + 147: TypePointer Private 146 + 148(mC2): 147(ptr) Variable Private + 149: TypePointer Private 145 + 173: 10 ConstantComposite 129 + 174: 17 ConstantComposite 35 + 178:6(float16_t) Constant 16384 + 181: 16(float) Constant 1082130432 + 185: TypeVector 7(int) 4 + 186: 7(int) Constant 32 + 187: TypeArray 185(ivec4) 186 + 188: TypePointer Workgroup 187 + 189(shmatrix): 188(ptr) Variable Workgroup + 190: 7(int) Constant 2 + 191: TypePointer Workgroup 185(ivec4) + 198: TypeVector 7(int) 3 + 199: 7(int) Constant 64 + 200: 198(ivec3) ConstantComposite 199 83 83 + 201(mC): 149(ptr) Variable Private + 202: 7(int) SpecConstantOp 5362 145 + 203: 57(int) SpecConstantOp 128 202 61 + 204: TypeArray 57(int) 203 + 205: TypePointer Private 204 + 206(arr): 205(ptr) Variable Private + 207: 7(int) SpecConstantOp 5362 145 + 208: 57(int) SpecConstantOp 128 207 61 + 209: TypeArray 57(int) 208 + 210: TypePointer Private 209 + 211(arr2): 210(ptr) Variable Private + 212(F): 16(float) SpecConstant 1077936128 + 213: TypeCooperativeMatrixNV 16(float) 8 125(Z) 9 + 214: 213 ConstantComposite 35 + 215:6(float16_t) Constant 15360 + 216: 10 ConstantComposite 215 + 217(S): TypeStruct 57(int) 57(int) 57(int) + 218: 57(int) Constant 12 + 219: 57(int) Constant 23 + 220: 57(int) Constant 34 + 221: 217(S) ConstantComposite 218 219 220 + 222(SC): 57(int) SpecConstant 1 + 223: TypeCooperativeMatrixNV 6(float16_t) 8 222(SC) 222(SC) + 224: TypeArray 223 222(SC) + 225: TypeArray 224 222(SC) + 226: TypePointer Private 225 + 227(scm): 226(ptr) Variable Private + 4(main): 2 Function None 3 + 5: Label + 34(m): 33(ptr) Variable Function + 52(m2): 51(ptr) Variable Function + 56(x): 55(ptr) Variable Function + 64(tempArg): 33(ptr) Variable Function + 81(tempArg): 51(ptr) Variable Function + 98(tempArg): 33(ptr) Variable Function + 111(D): 33(ptr) Variable Function + 112(A): 51(ptr) Variable Function + 114(B): 11(ptr) Variable Function + 116(C): 33(ptr) Variable Function + 120(l): 119(ptr) Variable Function + 128(F): 127(ptr) Variable Function + 133(a): 132(ptr) Variable Function + 137(md1): 55(ptr) Variable Function + 153(tempArg): 33(ptr) Variable Function + 159(tempArg): 51(ptr) Variable Function + 165(p1): 11(ptr) Variable Function + 166(param): 11(ptr) Variable Function + 169(p2): 18(ptr) Variable Function + 170(param): 18(ptr) Variable Function + 184(tempArg): 51(ptr) Variable Function + 194(ms): 51(ptr) Variable Function + Store 34(m) 36 + 37: 32 Load 34(m) + 38: 32 Load 34(m) + 39: 32 FAdd 37 38 + Store 34(m) 39 + 40: 32 Load 34(m) + 41: 32 Load 34(m) + 42: 32 FSub 40 41 + Store 34(m) 42 + 43: 32 Load 34(m) + 44: 32 FNegate 43 + Store 34(m) 44 + 46: 32 Load 34(m) + 47: 32 MatrixTimesScalar 46 45 + Store 34(m) 47 + 48: 32 Load 34(m) + 49: 32 MatrixTimesScalar 48 45 + Store 34(m) 49 + 53: 32 Load 34(m) + 54: 50 FConvert 53 + Store 52(m2) 54 + 59: 55(ptr) AccessChain 34(m) 58 + 60: 16(float) Load 59 + Store 56(x) 60 + 62: 16(float) Load 56(x) + 63: 55(ptr) AccessChain 34(m) 61 + Store 63 62 + 73: 72(ptr) AccessChain 70(block) 58 31 + 77: 32 CooperativeMatrixLoadNV 73 74 76 MakePointerVisibleKHR NonPrivatePointerKHR 71 + Store 64(tempArg) 77 + 78: 32 Load 64(tempArg) + Store 34(m) 78 + 79: 32 Load 34(m) + 80: 72(ptr) AccessChain 70(block) 58 31 + CooperativeMatrixStoreNV 80 79 74 76 MakePointerAvailableKHR NonPrivatePointerKHR 71 + 93: 92(ptr) AccessChain 91(block16) 58 31 + 94: 50 CooperativeMatrixLoadNV 93 74 76 MakePointerVisibleKHR NonPrivatePointerKHR 71 + Store 81(tempArg) 94 + 95: 50 Load 81(tempArg) + Store 52(m2) 95 + 96: 50 Load 52(m2) + 97: 92(ptr) AccessChain 91(block16) 58 31 + CooperativeMatrixStoreNV 97 96 74 76 MakePointerAvailableKHR NonPrivatePointerKHR 71 + 101: 100(ptr) AccessChain 91(block16) 99 + 102: 85(ptr) Load 101 MakePointerVisibleKHR NonPrivatePointerKHR 71 + 104: 103(ptr) AccessChain 102 58 31 + 105: 32 CooperativeMatrixLoadNV 104 74 76 Aligned 16 + Store 98(tempArg) 105 + 106: 32 Load 98(tempArg) + Store 34(m) 106 + 107: 32 Load 34(m) + 108: 100(ptr) AccessChain 91(block16) 99 + 109: 85(ptr) Load 108 MakePointerVisibleKHR NonPrivatePointerKHR 71 + 110: 103(ptr) AccessChain 109 58 31 + CooperativeMatrixStoreNV 110 107 74 76 Aligned 16 + 113: 50 Load 112(A) + 115: 10 Load 114(B) + 117: 32 Load 116(C) + 118: 32 CooperativeMatrixMulAddNV 113 115 117 + Store 111(D) 118 + Store 120(l) 122 + Store 128(F) 130 + 136: 55(ptr) AccessChain 133(a) 134 61 + Store 136 135 + Store 137(md1) 35 + 138: 32 Load 34(m) + 139: 32 Load 34(m) + 140: 32 FAdd 139 138 + Store 34(m) 140 + 142: 16(float) CompositeExtract 140 1234 + 143: 16(float) Load 137(md1) + 144: 16(float) FAdd 143 142 + Store 137(md1) 144 + 150: 149(ptr) AccessChain 148(mC2) 99 + 151: 145 Load 150 + 152: 149(ptr) AccessChain 148(mC2) 58 + Store 152 151 + 154: 72(ptr) AccessChain 70(block) 61 31 + 155: 32 CooperativeMatrixLoadNV 154 74 76 MakePointerVisibleKHR NonPrivatePointerKHR 71 + Store 153(tempArg) 155 + 156: 32 Load 153(tempArg) + Store 34(m) 156 + 157: 32 Load 34(m) + 158: 72(ptr) AccessChain 70(block) 61 31 + CooperativeMatrixStoreNV 158 157 74 76 MakePointerAvailableKHR NonPrivatePointerKHR 71 + 160: 92(ptr) AccessChain 91(block16) 61 31 + 161: 50 CooperativeMatrixLoadNV 160 74 76 MakePointerVisibleKHR NonPrivatePointerKHR 71 + Store 159(tempArg) 161 + 162: 50 Load 159(tempArg) + Store 52(m2) 162 + 163: 50 Load 52(m2) + 164: 92(ptr) AccessChain 91(block16) 61 31 + CooperativeMatrixStoreNV 164 163 74 76 MakePointerAvailableKHR NonPrivatePointerKHR 71 + 167: 10 Load 165(p1) + Store 166(param) 167 + 168: 10 FunctionCall 14(f16(f161;) 166(param) + Store 165(p1) 168 + 171: 17 Load 169(p2) + Store 170(param) 171 + 172: 17 FunctionCall 21(f32(f1;) 170(param) + Store 169(p2) 172 + Store 165(p1) 173 + Store 169(p2) 174 + 175: 10 Load 165(p1) + 176: 10 Load 165(p1) + 177: 10 FDiv 176 175 + Store 165(p1) 177 + 179: 10 Load 165(p1) + 180: 10 MatrixTimesScalar 179 178 + Store 165(p1) 180 + 182: 17 Load 169(p2) + 183: 17 MatrixTimesScalar 182 181 + Store 169(p2) 183 + 192: 191(ptr) AccessChain 189(shmatrix) 83 + 193: 50 CooperativeMatrixLoadNV 192 190 76 MakePointerVisibleKHR NonPrivatePointerKHR 190 + Store 184(tempArg) 193 + 195: 50 Load 184(tempArg) + Store 194(ms) 195 + 196: 50 Load 194(ms) + 197: 191(ptr) AccessChain 189(shmatrix) 83 + CooperativeMatrixStoreNV 197 196 190 76 MakePointerAvailableKHR NonPrivatePointerKHR 190 + Return + FunctionEnd + 14(f16(f161;): 10 Function None 12 + 13(m): 11(ptr) FunctionParameter + 15: Label + 23: 10 Load 13(m) + 24: 10 FNegate 23 + ReturnValue 24 + FunctionEnd + 21(f32(f1;): 17 Function None 19 + 20(m): 18(ptr) FunctionParameter + 22: Label + 27: 17 Load 20(m) + 28: 17 FNegate 27 + ReturnValue 28 + FunctionEnd diff --git a/Test/baseResults/spv.coopmat_Error.comp.out b/Test/baseResults/spv.coopmat_Error.comp.out new file mode 100644 index 00000000..49223b00 --- /dev/null +++ b/Test/baseResults/spv.coopmat_Error.comp.out @@ -0,0 +1,35 @@ +spv.coopmat_Error.comp +ERROR: 0:8: 'ftemplate16' : unexpected type parameters +ERROR: 0:10: 'fnoparams' : expected four type parameters +ERROR: 0:12: 'fbadbits' : expected 16, 32, or 64 bits for first type parameter +ERROR: 0:14: 'fbadnumparams' : expected four type parameters +ERROR: 0:18: '' : type parameter must be a constant integer expression +ERROR: 0:20: 'constant_id' : can only be applied to 'const'-qualified scalar +ERROR: 0:22: 'Cooperative matrix types must not be used in shared memory' : qualifier +ERROR: 0:25: 'bufmat' : member of block cannot be or contain a cooperative matrix type +ERROR: 0:34: 'assign' : cannot convert from ' temp<16, 3, 16, 8> float16_t' to ' temp<32, 3, 16, 8> highp float' +ERROR: 0:35: 'assign' : cannot convert from ' temp<16, 3, 16, 8> float16_t' to ' temp<32, 3, 16, 8> highp float' +ERROR: 0:40: 'assign' : cannot convert from ' temp<16, 3, 8, 8> float16_t' to ' temp<16, 3, 16, 8> float16_t' +ERROR: 0:46: 'assign' : cannot convert from ' temp<16, 3, 8, 1> float16_t' to ' temp<16, 3, 8, 1> float16_t' +ERROR: 0:49: 'constructor' : too many arguments +ERROR: 0:49: 'assign' : cannot convert from ' const float' to ' temp<16, 3, 8, 8> float16_t' +ERROR: 0:53: 'constructor' : Cooperative matrix constructor argument must be scalar or cooperative matrix +ERROR: 0:53: '=' : cannot convert from ' const float' to ' temp<32, 3, 4, 4> highp float' +ERROR: 0:56: 'expression' : left of '[' is not of type array, matrix, or vector +ERROR: 0:59: '.' : cannot apply to a cooperative matrix type: x +ERROR: 0:61: '*' : wrong operand types: no operation '*' exists that takes a left-hand operand of type ' temp<16, 3, 16, 8> float16_t' and a right operand of type ' temp<16, 3, 16, 8> float16_t' (or there is no acceptable conversion) +ERROR: 0:63: '+' : wrong operand types: no operation '+' exists that takes a left-hand operand of type ' temp<16, 3, 16, 8> float16_t' and a right operand of type ' const float' (or there is no acceptable conversion) +ERROR: 0:64: '-' : wrong operand types: no operation '-' exists that takes a left-hand operand of type ' temp<16, 3, 16, 8> float16_t' and a right operand of type ' const float' (or there is no acceptable conversion) +ERROR: 0:65: '/' : wrong operand types: no operation '/' exists that takes a left-hand operand of type ' temp<16, 3, 16, 8> float16_t' and a right operand of type ' const float' (or there is no acceptable conversion) +ERROR: 0:66: 'assign' : cannot convert from ' const float' to ' temp<16, 3, 16, 8> float16_t' +ERROR: 0:67: 'assign' : cannot convert from ' const float' to ' temp<16, 3, 16, 8> float16_t' +ERROR: 0:68: 'assign' : cannot convert from ' const float' to ' temp<16, 3, 16, 8> float16_t' +ERROR: 0:70: '*' : wrong operand types: no operation '*' exists that takes a left-hand operand of type ' temp<16, 3, 16, 8> float16_t' and a right operand of type ' const float' (or there is no acceptable conversion) +ERROR: 0:71: '*' : wrong operand types: no operation '*' exists that takes a left-hand operand of type ' const float' and a right operand of type ' temp<16, 3, 16, 8> float16_t' (or there is no acceptable conversion) +ERROR: 0:72: '*' : wrong operand types: no operation '*' exists that takes a left-hand operand of type ' temp<32, 3, 16, 8> highp float' and a right operand of type ' const float16_t' (or there is no acceptable conversion) +ERROR: 0:73: '*' : wrong operand types: no operation '*' exists that takes a left-hand operand of type ' const float16_t' and a right operand of type ' temp<32, 3, 16, 8> highp float' (or there is no acceptable conversion) +ERROR: 0:75: 'transpose' : no matching overloaded function found +ERROR: 30 compilation errors. No code generated. + + +SPIR-V is not generated for failed compile or link diff --git a/Test/baseResults/vulkan.vert.out b/Test/baseResults/vulkan.vert.out index 19fdade5..6bfa188a 100644 --- a/Test/baseResults/vulkan.vert.out +++ b/Test/baseResults/vulkan.vert.out @@ -30,14 +30,11 @@ ERROR: 0:32: 'initializer' : can't use with types containing arrays sized with a ERROR: 0:34: '=' : can't use with types containing arrays sized with a specialization constant ERROR: 0:35: '==' : can't use with types containing arrays sized with a specialization constant ERROR: 0:39: 'set' : cannot be used with push_constant -ERROR: 0:49: '[]' : only outermost dimension of an array of arrays can be a specialization constant -ERROR: 0:50: '[]' : only outermost dimension of an array of arrays can be a specialization constant -ERROR: 0:51: '[]' : only outermost dimension of an array of arrays can be a specialization constant ERROR: 0:54: '[]' : only outermost dimension of an array of arrays can be a specialization constant ERROR: 0:54: 'location' : SPIR-V requires location for user input/output ERROR: 0:58: 'location' : SPIR-V requires location for user input/output ERROR: 0:65: 'location' : overlapping use of location 10 -ERROR: 38 compilation errors. No code generated. +ERROR: 35 compilation errors. No code generated. SPIR-V is not generated for failed compile or link diff --git a/Test/spv.1.3.coopmat.comp b/Test/spv.1.3.coopmat.comp new file mode 100644 index 00000000..23e0b781 --- /dev/null +++ b/Test/spv.1.3.coopmat.comp @@ -0,0 +1,28 @@ +#version 450 core +#extension GL_KHR_memory_scope_semantics : enable +#extension GL_NV_cooperative_matrix : enable +#extension GL_EXT_shader_explicit_arithmetic_types_float16 : enable + +#pragma use_variable_pointers + +layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in; + +layout(set = 0, binding = 0) coherent buffer Block { + float y[1024*1024]; + float x[]; +} block; + + +void main() +{ + fcoopmatNV<32, gl_ScopeSubgroup, 16, 8> m = fcoopmatNV<32, gl_ScopeSubgroup, 16, 8>(0.0); + + m = m + m; + m = m - m; + m = -m; + m = 2.0*m; + m = m*2.0; + + coopMatLoadNV(m, block.x, 16, 128, false); + coopMatStoreNV(m, block.x, 16, 128, false); +} diff --git a/Test/spv.coopmat.comp b/Test/spv.coopmat.comp new file mode 100644 index 00000000..ab4292fe --- /dev/null +++ b/Test/spv.coopmat.comp @@ -0,0 +1,115 @@ +#version 450 core +#extension GL_KHR_memory_scope_semantics : enable +#extension GL_NV_cooperative_matrix : enable +#extension GL_EXT_shader_explicit_arithmetic_types_float16 : enable +#extension GL_EXT_buffer_reference : enable + +layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in; + +const int X = 8; +layout(constant_id = 0) const int Y = 2; +const int Z = X*Y; + +fcoopmatNV<16, gl_ScopeSubgroup, Z, 8> mC; +fcoopmatNV<16, gl_ScopeSubgroup, Z, 8> mC2[3]; + +int arr[mC.length()]; +int arr2[mC2[1].length()]; + +layout(constant_id = 1) const float F = 3.0; + +const fcoopmatNV<32, gl_ScopeSubgroup, Z, 8> mD = fcoopmatNV<32, gl_ScopeSubgroup, Z, 8>(0.0); +const fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> mD2 = fcoopmatNV<16, gl_ScopeSubgroup, 8, 8>(1); + +struct S { int a; int b; int c; }; + +const S s = S(12, 23, 34); + +layout(set = 0, binding = 0, buffer_reference) coherent buffer Block { + float y[1024*1024]; + float x[]; +} block; + +layout(set = 0, binding = 0) coherent buffer Block16 { + float16_t y[1024*1024]; + float16_t x[]; + + Block b; +} block16; + +fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> f16(fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> m) { return -m; } +fcoopmatNV<32, gl_ScopeSubgroup, 8, 8> f32(fcoopmatNV<32, gl_ScopeSubgroup, 8, 8> m) { return -m; } + +layout(constant_id = 2) const int SC = 1; +fcoopmatNV<16, gl_ScopeSubgroup, SC, SC> scm[SC][SC]; + +// sized for fcoopmatNV<16, gl_ScopeSubgroup, 16, 16> +shared uvec4 shmatrix[16*16*2/16]; + +void main() +{ + fcoopmatNV<32, gl_ScopeSubgroup, 16, (2>1?8:4)> m = fcoopmatNV<32, gl_ScopeSubgroup, 16, (2>1?8:4)>(0.0); + + m = m + m; + m = m - m; + m = -m; + m = 2.0*m; + m = m*2.0; + + fcoopmatNV<16, gl_ScopeSubgroup, 16, 8> m2 = fcoopmatNV<16, gl_ScopeSubgroup, 16, 8>(m); + + float x = m[1]; + m[0] = x; + + coopMatLoadNV(m, block.x, 16, 128, false); + coopMatStoreNV(m, block.x, 16, 128, false); + coopMatLoadNV(m2, block16.x, 16, 128, false); + coopMatStoreNV(m2, block16.x, 16, 128, false); + coopMatLoadNV(m, block16.b.x, 16, 128, false); + coopMatStoreNV(m, block16.b.x, 16, 128, false); + + fcoopmatNV<16, gl_ScopeSubgroup, 16, 8> A; + fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> B; + fcoopmatNV<32, gl_ScopeSubgroup, 16, 8> C; + fcoopmatNV<32, gl_ScopeSubgroup, 16, 8> D; + D = coopMatMulAddNV(A, B, C); + + int l = D.length(); + + fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> E; + + fcoopmatNV<16, gl_ScopeSubgroup, Z, Z> F = fcoopmatNV<16, gl_ScopeSubgroup, Z, Z>(0.0); + + fcoopmatNV<32, gl_ScopeSubgroup, 16, (2>1?8:4)> a[5]; + a[3][0] = 1.0; + + float md1 = mD[1]; + + md1 += (m += m)[1234]; + + mC2[1] = mC2[2]; + + coopMatLoadNV(m, block.y, 16, 128, false); + coopMatStoreNV(m, block.y, 16, 128, false); + coopMatLoadNV(m2, block16.y, 16, 128, false); + coopMatStoreNV(m2, block16.y, 16, 128, false); + + fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> p1; + fcoopmatNV<32, gl_ScopeSubgroup, 8, 8> p2; + + p1 = f16(p1); + p2 = f32(p2); + + p1 = fcoopmatNV<16, gl_ScopeSubgroup, 8, 8>(0.0); + p2 = fcoopmatNV<32, gl_ScopeSubgroup, 8, 8>(0.0); + + p1 /= p1; + + p1 *= float16_t(2.0); + p2 *= 4.0; + + fcoopmatNV<16, gl_ScopeSubgroup, 16, 8> ms; + coopMatLoadNV(ms, shmatrix, 1, 2, false); + coopMatStoreNV(ms, shmatrix, 1, 2, false); + +} diff --git a/Test/spv.coopmat_Error.comp b/Test/spv.coopmat_Error.comp new file mode 100644 index 00000000..220aa980 --- /dev/null +++ b/Test/spv.coopmat_Error.comp @@ -0,0 +1,76 @@ +#version 450 core +#extension GL_KHR_memory_scope_semantics : enable +#extension GL_NV_cooperative_matrix : enable +#extension GL_EXT_shader_explicit_arithmetic_types_float16 : enable + +layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in; + +float<16> ftemplate16; + +fcoopmatNV fnoparams; + +fcoopmatNV<8, gl_ScopeSubgroup, 8, 8> fbadbits; + +fcoopmatNV<16, gl_ScopeSubgroup, 8> fbadnumparams; + +int X = 8; + +fcoopmatNV<16, gl_ScopeSubgroup, 8, X> fbadparam; + +layout(constant_id = 0) int Y = 1; + +shared fcoopmatNV<16, gl_ScopeSubgroup, 16, 16> sharedmat; + +layout(set = 0, binding = 0) buffer InvBlock { + fcoopmatNV<16, gl_ScopeSubgroup, 16, 16> bufmat; +} invblock; + +void main() +{ + fcoopmatNV<32, gl_ScopeSubgroup, 16, 8> f32_16_8; + fcoopmatNV<16, gl_ScopeSubgroup, 16, 8> f16_16_8; + + // invalid implicit conversions + f32_16_8 = f16_16_8; + f32_16_8 = f16_16_8 + f16_16_8; + + fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> f16_8_8; + + // mismatching dimensions + f16_16_8 = f16_8_8; + + fcoopmatNV<16, gl_ScopeSubgroup, 8, Y> f16_8_Y; + fcoopmatNV<16, gl_ScopeSubgroup, 8, (Y+1)> f16_8_Y1; + + // mismatching dimensions with specialization constants + f16_8_Y = f16_8_Y1; + + // wrong arguments for constructor + f16_8_8 = fcoopmatNV<16, gl_ScopeSubgroup, 8, 8>(1, 1); + + // can't construct from a builtin type + mat4 m4; + fcoopmatNV<32, gl_ScopeSubgroup, 4, 4> f32_4_4 = fcoopmatNV<32, gl_ScopeSubgroup, 4, 4>(m4); + + // only support a single array subscript + f16_16_8[0][0]; + + // don't support scalar component selection + f16_16_8.x; + + f16_16_8 * f16_16_8; + + f16_16_8 + 1.0; + f16_16_8 - 1.0; + f16_16_8 / 1.0; + f16_16_8 += 1.0; + f16_16_8 -= 1.0; + f16_16_8 /= 1.0; + + f16_16_8*2.0; + 2.0*f16_16_8; + f32_16_8*float16_t(2.0); + float16_t(2.0)*f32_16_8; + + transpose(f16_8_8); +} diff --git a/Test/vulkan.vert b/Test/vulkan.vert index a6af2d57..0fad1de9 100644 --- a/Test/vulkan.vert +++ b/Test/vulkan.vert @@ -46,9 +46,9 @@ layout(set = 1, push_constant) uniform badpc { int a; } badpcI; // ERROR, no de #error VULKAN should be 100 #endif -float AofA0[2][arraySize]; // ERROR, only outer dimension -float AofA1[arraySize][arraySize]; // ERROR, only outer dimension -float AofA2[arraySize][2 + arraySize]; // ERROR, only outer dimension +float AofA0[2][arraySize]; +float AofA1[arraySize][arraySize]; +float AofA2[arraySize][2 + arraySize]; float AofA3[arraySize][2]; out ban1 { // ERROR, only outer dimension diff --git a/glslang/Include/Types.h b/glslang/Include/Types.h index 4663a35a..1cbecab7 100644 --- a/glslang/Include/Types.h +++ b/glslang/Include/Types.h @@ -1235,9 +1235,11 @@ public: int vectorSize : 4; int matrixCols : 4; int matrixRows : 4; + bool coopmat : 1; TArraySizes* arraySizes; const TType* userDef; TSourceLoc loc; + TArraySizes* typeParameters; void initType(const TSourceLoc& l) { @@ -1248,6 +1250,8 @@ public: arraySizes = nullptr; userDef = nullptr; loc = l; + typeParameters = nullptr; + coopmat = false; } void initQualifiers(bool global = false) @@ -1299,8 +1303,8 @@ public: // for "empty" type (no args) or simple scalar/vector/matrix explicit TType(TBasicType t = EbtVoid, TStorageQualifier q = EvqTemporary, int vs = 1, int mc = 0, int mr = 0, bool isVector = false) : - basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), vector1(isVector && vs == 1), - arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr) + basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), vector1(isVector && vs == 1), coopmat(false), + arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr) { sampler.clear(); qualifier.clear(); @@ -1310,8 +1314,8 @@ public: // for explicit precision qualifier TType(TBasicType t, TStorageQualifier q, TPrecisionQualifier p, int vs = 1, int mc = 0, int mr = 0, bool isVector = false) : - basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), vector1(isVector && vs == 1), - arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr) + basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), vector1(isVector && vs == 1), coopmat(false), + arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr) { sampler.clear(); qualifier.clear(); @@ -1323,8 +1327,8 @@ public: // for turning a TPublicType into a TType, using a shallow copy explicit TType(const TPublicType& p) : basicType(p.basicType), - vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false), - arraySizes(p.arraySizes), structure(nullptr), fieldName(nullptr), typeName(nullptr) + vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false), coopmat(p.coopmat), + arraySizes(p.arraySizes), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(p.typeParameters) { if (basicType == EbtSampler) sampler = p.sampler; @@ -1340,12 +1344,18 @@ public: } typeName = NewPoolTString(p.userDef->getTypeName().c_str()); } + if (p.coopmat && p.basicType == EbtFloat && + p.typeParameters && p.typeParameters->getNumDims() > 0 && + p.typeParameters->getDimSize(0) == 16) { + basicType = EbtFloat16; + qualifier.precision = EpqNone; + } } // for construction of sampler types TType(const TSampler& sampler, TStorageQualifier q = EvqUniform, TArraySizes* as = nullptr) : - basicType(EbtSampler), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), + basicType(EbtSampler), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmat(false), arraySizes(as), structure(nullptr), fieldName(nullptr), typeName(nullptr), - sampler(sampler) + sampler(sampler), typeParameters(nullptr) { qualifier.clear(); qualifier.storage = q; @@ -1386,13 +1396,16 @@ public: // dereference from vector to scalar vectorSize = 1; vector1 = false; + } else if (isCoopMat()) { + coopmat = false; + typeParameters = nullptr; } } } // for making structures, ... TType(TTypeList* userDef, const TString& n) : - basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), - arraySizes(nullptr), structure(userDef), fieldName(nullptr) + basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmat(false), + arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr) { sampler.clear(); qualifier.clear(); @@ -1400,8 +1413,8 @@ public: } // For interface blocks TType(TTypeList* userDef, const TString& n, const TQualifier& q) : - basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), - qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr) + basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmat(false), + qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr) { sampler.clear(); typeName = NewPoolTString(n.c_str()); @@ -1439,6 +1452,8 @@ public: } else { referentType = copyOf.referentType; } + typeParameters = copyOf.typeParameters; + coopmat = copyOf.coopmat; } // Make complete copy of the whole type graph rooted at 'copyOf'. @@ -1502,6 +1517,8 @@ public: virtual const TArraySizes* getArraySizes() const { return arraySizes; } virtual TArraySizes* getArraySizes() { return arraySizes; } virtual TType* getReferentType() const { return referentType; } + virtual const TArraySizes* getTypeParameters() const { return typeParameters; } + virtual TArraySizes* getTypeParameters() { return typeParameters; } virtual bool isScalar() const { return ! isVector() && ! isMatrix() && ! isStruct() && ! isArray(); } virtual bool isScalarOrVec1() const { return isScalar() || vector1; } @@ -1544,6 +1561,8 @@ public: virtual bool isImage() const { return basicType == EbtSampler && getSampler().isImage(); } virtual bool isSubpass() const { return basicType == EbtSampler && getSampler().isSubpass(); } virtual bool isTexture() const { return basicType == EbtSampler && getSampler().isTexture(); } + virtual bool isParameterized() const { return typeParameters != nullptr; } + virtual bool isCoopMat() const { return coopmat; } // return true if this type contains any subtype which satisfies the given predicate. template @@ -1633,6 +1652,11 @@ public: return containsBasicType(EbtInt8) || containsBasicType(EbtUint8); } + virtual bool containsCoopMat() const + { + return contains([](const TType* t) { return t->coopmat; } ); + } + // Array editing methods. Array descriptors can be shared across // type instances. This allows all uses of the same array // to be updated at once. E.g., all nodes can be explicitly sized @@ -1705,6 +1729,46 @@ public: } } + + void updateTypeParameters(const TType& type) + { + // For when we may already be sharing existing array descriptors, + // keeping the pointers the same, just updating the contents. + assert(typeParameters != nullptr); + assert(type.typeParameters != nullptr); + *typeParameters = *type.typeParameters; + } + void copyTypeParameters(const TArraySizes& s) + { + // For setting a fresh new set of type parameters, not yet worrying about sharing. + typeParameters = new TArraySizes; + *typeParameters = s; + } + void transferTypeParameters(TArraySizes* s) + { + // For setting an already allocated set of sizes that this type can use + // (no copy made). + typeParameters = s; + } + void clearTypeParameters() + { + typeParameters = nullptr; + } + + // Add inner array sizes, to any existing sizes, via copy; the + // sizes passed in can still be reused for other purposes. + void copyTypeParametersInnerSizes(const TArraySizes* s) + { + if (s != nullptr) { + if (typeParameters == nullptr) + copyTypeParameters(*s); + else + typeParameters->addInnerSizes(*s); + } + } + + + const char* getBasicString() const { return TType::getBasicString(basicType); @@ -1919,6 +1983,15 @@ public: } } } + if (isParameterized()) { + appendStr("<"); + for(int i = 0; i < (int)typeParameters->getNumDims(); ++i) { + appendInt(typeParameters->getDimSize(i)); + if (i != (int)typeParameters->getNumDims() - 1) + appendStr(", "); + } + appendStr(">"); + } if (qualifier.precision != EpqNone) { appendStr(" "); appendStr(getPrecisionQualifierString()); @@ -2075,6 +2148,13 @@ public: return arraySizes->sameInnerArrayness(*right.arraySizes); } + // See if two type's parameters match + bool sameTypeParameters(const TType& right) const + { + return ((typeParameters == nullptr && right.typeParameters == nullptr) || + (typeParameters != nullptr && right.typeParameters != nullptr && *typeParameters == *right.typeParameters)); + } + // See if two type's elements match in all ways except basic type bool sameElementShape(const TType& right) const { @@ -2083,14 +2163,23 @@ public: matrixCols == right.matrixCols && matrixRows == right.matrixRows && vector1 == right.vector1 && + coopmat == right.coopmat && sameStructType(right) && sameReferenceType(right); } + // See if a cooperative matrix type parameter with unspecified parameters is + // an OK function parameter + bool coopMatParameterOK(const TType& right) const + { + return coopmat && right.coopmat && + typeParameters == nullptr && right.typeParameters != nullptr; + } + // See if two types match in all ways (just the actual type, not qualification) bool operator==(const TType& right) const { - return sameElementType(right) && sameArrayness(right); + return sameElementType(right) && sameArrayness(right) && sameTypeParameters(right); } bool operator!=(const TType& right) const @@ -2115,6 +2204,11 @@ protected: *arraySizes = *copyOf.arraySizes; } + if (copyOf.typeParameters) { + typeParameters = new TArraySizes; + *typeParameters = *copyOf.typeParameters; + } + if (copyOf.isStruct() && copyOf.structure) { auto prevCopy = copiedMap.find(copyOf.structure); if (prevCopy != copiedMap.end()) @@ -2150,6 +2244,7 @@ protected: // functionality is added. // HLSL does have a 1-component vectors, so this will be true to disambiguate // from a scalar. + bool coopmat : 1; TQualifier qualifier; TArraySizes* arraySizes; // nullptr unless an array; can be shared across types @@ -2162,6 +2257,7 @@ protected: TString *fieldName; // for structure field names TString *typeName; // for structure type name TSampler sampler; + TArraySizes* typeParameters;// nullptr unless a parameterized type; can be shared across types }; } // end namespace glslang diff --git a/glslang/Include/arrays.h b/glslang/Include/arrays.h index af8f560b..7f047d9f 100644 --- a/glslang/Include/arrays.h +++ b/glslang/Include/arrays.h @@ -254,7 +254,9 @@ struct TArraySizes { void addInnerSize() { addInnerSize((unsigned)UnsizedArraySize); } void addInnerSize(int s) { addInnerSize((unsigned)s, nullptr); } void addInnerSize(int s, TIntermTyped* n) { sizes.push_back((unsigned)s, n); } - void addInnerSize(TArraySize pair) { sizes.push_back(pair.size, pair.node); } + void addInnerSize(TArraySize pair) { + sizes.push_back(pair.size, pair.node); + } void addInnerSizes(const TArraySizes& s) { sizes.push_back(s.sizes); } void changeOuterSize(int s) { sizes.changeFront((unsigned)s); } int getImplicitSize() const { return implicitArraySize; } @@ -318,8 +320,8 @@ struct TArraySizes { void setVariablyIndexed() { variablyIndexed = true; } bool isVariablyIndexed() const { return variablyIndexed; } - bool operator==(const TArraySizes& rhs) { return sizes == rhs.sizes; } - bool operator!=(const TArraySizes& rhs) { return sizes != rhs.sizes; } + bool operator==(const TArraySizes& rhs) const { return sizes == rhs.sizes; } + bool operator!=(const TArraySizes& rhs) const { return sizes != rhs.sizes; } protected: TSmallArrayVector sizes; diff --git a/glslang/Include/intermediate.h b/glslang/Include/intermediate.h index 4b6bcb7b..32e684cd 100644 --- a/glslang/Include/intermediate.h +++ b/glslang/Include/intermediate.h @@ -615,6 +615,10 @@ enum TOperator { EOpAny, EOpAll, + EOpCooperativeMatrixLoad, + EOpCooperativeMatrixStore, + EOpCooperativeMatrixMulAdd, + // // Branch // @@ -737,6 +741,7 @@ enum TOperator { EOpConstructTextureSampler, EOpConstructNonuniform, // expected to be transformed away, not present in final AST EOpConstructReference, + EOpConstructCooperativeMatrix, EOpConstructGuardEnd, // diff --git a/glslang/MachineIndependent/Constant.cpp b/glslang/MachineIndependent/Constant.cpp old mode 100755 new mode 100644 index a6adab1f..1cf65657 --- a/glslang/MachineIndependent/Constant.cpp +++ b/glslang/MachineIndependent/Constant.cpp @@ -1354,7 +1354,9 @@ TIntermTyped* TIntermediate::foldDereference(TIntermTyped* node, int index, cons // arrays, vectors, matrices, all use simple multiplicative math // while structures need to add up heterogeneous members int start; - if (node->isArray() || ! node->isStruct()) + if (node->getType().isCoopMat()) + start = 0; + else if (node->isArray() || ! node->isStruct()) start = size * index; else { // it is a structure diff --git a/glslang/MachineIndependent/Initialize.cpp b/glslang/MachineIndependent/Initialize.cpp old mode 100755 new mode 100644 index e399eadf..f4df3e71 --- a/glslang/MachineIndependent/Initialize.cpp +++ b/glslang/MachineIndependent/Initialize.cpp @@ -4928,6 +4928,34 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV commonBuiltins.append("void controlBarrier(int, int, int, int);\n" "void memoryBarrier(int, int, int);\n"); + if (profile != EEsProfile && version >= 450) { + // coopMatStoreNV perhaps ought to have "out" on the buf parameter, but + // adding it introduces undesirable tempArgs on the stack. What we want + // is more like "buf" thought of as a pointer value being an in parameter. + stageBuiltins[EShLangCompute].append( + "void coopMatLoadNV(out fcoopmatNV m, volatile coherent float16_t[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatLoadNV(out fcoopmatNV m, volatile coherent float[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatLoadNV(out fcoopmatNV m, volatile coherent uint8_t[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatLoadNV(out fcoopmatNV m, volatile coherent uint16_t[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatLoadNV(out fcoopmatNV m, volatile coherent uint[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatLoadNV(out fcoopmatNV m, volatile coherent uint64_t[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatLoadNV(out fcoopmatNV m, volatile coherent uvec2[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatLoadNV(out fcoopmatNV m, volatile coherent uvec4[] buf, uint element, uint stride, bool colMajor);\n" + + "void coopMatStoreNV(fcoopmatNV m, volatile coherent float16_t[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatStoreNV(fcoopmatNV m, volatile coherent float[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatStoreNV(fcoopmatNV m, volatile coherent float64_t[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatStoreNV(fcoopmatNV m, volatile coherent uint8_t[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatStoreNV(fcoopmatNV m, volatile coherent uint16_t[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatStoreNV(fcoopmatNV m, volatile coherent uint[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatStoreNV(fcoopmatNV m, volatile coherent uint64_t[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatStoreNV(fcoopmatNV m, volatile coherent uvec2[] buf, uint element, uint stride, bool colMajor);\n" + "void coopMatStoreNV(fcoopmatNV m, volatile coherent uvec4[] buf, uint element, uint stride, bool colMajor);\n" + + "fcoopmatNV coopMatMulAddNV(fcoopmatNV A, fcoopmatNV B, fcoopmatNV C);\n" + ); + } + //============================================================================ // // Prototypes for built-in functions seen by fragment shaders only. @@ -8658,6 +8686,11 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.setFunctionExtensions("subgroupMemoryBarrierShared", 1, &E_GL_KHR_shader_subgroup_basic); } + + symbolTable.setFunctionExtensions("coopMatLoadNV", 1, &E_GL_NV_cooperative_matrix); + symbolTable.setFunctionExtensions("coopMatStoreNV", 1, &E_GL_NV_cooperative_matrix); + symbolTable.setFunctionExtensions("coopMatMulAddNV", 1, &E_GL_NV_cooperative_matrix); + break; #ifdef NV_EXTENSIONS case EShLangRayGenNV: @@ -9462,6 +9495,9 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.relateToOperator("fwidthCoarse",EOpFwidthCoarse); } #endif + symbolTable.relateToOperator("coopMatLoadNV", EOpCooperativeMatrixLoad); + symbolTable.relateToOperator("coopMatStoreNV", EOpCooperativeMatrixStore); + symbolTable.relateToOperator("coopMatMulAddNV", EOpCooperativeMatrixMulAdd); break; #ifdef NV_EXTENSIONS diff --git a/glslang/MachineIndependent/Intermediate.cpp b/glslang/MachineIndependent/Intermediate.cpp old mode 100755 new mode 100644 index 32b38a0c..8ab4af9f --- a/glslang/MachineIndependent/Intermediate.cpp +++ b/glslang/MachineIndependent/Intermediate.cpp @@ -725,6 +725,11 @@ TIntermTyped* TIntermediate::createConversion(TBasicType convertTo, TIntermTyped return newNode; } +TIntermTyped* TIntermediate::addConversion(TBasicType convertTo, TIntermTyped* node) const +{ + return createConversion(convertTo, node); +} + // For converting a pair of operands to a binary operation to compatible // types with each other, relative to the operation in 'op'. // This does not cover assignment operations, which is asymmetric in that the @@ -751,6 +756,10 @@ TIntermediate::addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* no // If differing arrays, then no conversions. if (node0->getType().isArray() || node1->getType().isArray()) return std::make_tuple(nullptr, nullptr); + + // No implicit conversions for operations involving cooperative matrices + if (node0->getType().isCoopMat() || node1->getType().isCoopMat()) + return std::make_tuple(node0, node1); } auto promoteTo = std::make_tuple(EbtNumTypes, EbtNumTypes); @@ -983,6 +992,7 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EOpSequence: case EOpConstructStruct: + case EOpConstructCooperativeMatrix: if (type.getBasicType() == EbtReference || node->getType().getBasicType() == EbtReference) { // types must match to assign a reference @@ -998,7 +1008,7 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt if (canImplicitlyPromote(node->getBasicType(), type.getBasicType(), op)) promoteTo = type.getBasicType(); else - return nullptr; + return nullptr; break; // For GLSL, there are no conversions needed; the shift amount just needs to be an @@ -1847,6 +1857,9 @@ TOperator TIntermediate::mapTypeToConstructorOp(const TType& type) const if (type.getQualifier().nonUniform) return EOpConstructNonuniform; + if (type.isCoopMat()) + return EOpConstructCooperativeMatrix; + switch (type.getBasicType()) { case EbtStruct: op = EOpConstructStruct; @@ -3319,6 +3332,40 @@ bool TIntermediate::promoteBinary(TIntermBinary& node) break; } + if (left->getType().isCoopMat() || right->getType().isCoopMat()) { + if (left->getType().isCoopMat() && right->getType().isCoopMat() && + *left->getType().getTypeParameters() != *right->getType().getTypeParameters()) { + return false; + } + switch (op) { + case EOpMul: + case EOpMulAssign: + if (left->getType().isCoopMat() && right->getType().isCoopMat()) { + return false; + } + if (op == EOpMulAssign && right->getType().isCoopMat()) { + return false; + } + node.setOp(op == EOpMulAssign ? EOpMatrixTimesScalarAssign : EOpMatrixTimesScalar); + if (right->getType().isCoopMat()) { + node.setType(right->getType()); + } + return true; + case EOpAdd: + case EOpSub: + case EOpDiv: + case EOpAssign: + // These require both to be cooperative matrices + if (!left->getType().isCoopMat() || !right->getType().isCoopMat()) { + return false; + } + return true; + default: + break; + } + return false; + } + // Finish handling the case, for all ops, where both operands are scalars. if (left->isScalar() && right->isScalar()) return true; diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp old mode 100755 new mode 100644 index cf40baa1..f0dbec25 --- a/glslang/MachineIndependent/ParseHelper.cpp +++ b/glslang/MachineIndependent/ParseHelper.cpp @@ -275,6 +275,12 @@ void TParseContext::handlePragma(const TSourceLoc& loc, const TVector& if (tokens.size() != 1) error(loc, "extra tokens", "#pragma", ""); intermediate.setUseVulkanMemoryModel(); + } else if (spvVersion.spv > 0 && tokens[0].compare("use_variable_pointers") == 0) { + if (tokens.size() != 1) + error(loc, "extra tokens", "#pragma", ""); + if (spvVersion.spv < glslang::EShTargetSpv_1_3) + error(loc, "requires SPIR-V 1.3", "#pragma use_variable_pointers", ""); + intermediate.setUseVariablePointers(); } else if (tokens[0].compare("once") == 0) { warn(loc, "not implemented", "#pragma once", ""); } else if (tokens[0].compare("glslang_binary_double_output") == 0) @@ -371,7 +377,7 @@ TIntermTyped* TParseContext::handleBracketDereference(const TSourceLoc& loc, TIn // basic type checks... variableCheck(base); - if (! base->isArray() && ! base->isMatrix() && ! base->isVector()) { + if (! base->isArray() && ! base->isMatrix() && ! base->isVector() && ! base->getType().isCoopMat()) { if (base->getAsSymbolNode()) error(loc, " left of '[' is not of type array, matrix, or vector ", base->getAsSymbolNode()->getName().c_str(), ""); else @@ -767,7 +773,7 @@ TIntermTyped* TParseContext::handleDotDereference(const TSourceLoc& loc, TInterm const char* feature = ".length() on vectors and matrices"; requireProfile(loc, ~EEsProfile, feature); profileRequires(loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, feature); - } else { + } else if (!base->getType().isCoopMat()) { error(loc, "does not operate on this type:", field.c_str(), base->getType().getCompleteString().c_str()); return base; @@ -784,6 +790,11 @@ TIntermTyped* TParseContext::handleDotDereference(const TSourceLoc& loc, TInterm return base; } + if (base->getType().isCoopMat()) { + error(loc, "cannot apply to a cooperative matrix type:", ".", field.c_str()); + return base; + } + // It's neither an array nor .length() if we get here, // leaving swizzles and struct/block dereferences. @@ -1204,6 +1215,13 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction } result = addOutputArgumentConversions(*fnCandidate, *result->getAsAggregate()); } + + if (result->getAsTyped()->getType().isCoopMat() && + !result->getAsTyped()->getType().isParameterized()) { + assert(fnCandidate->getBuiltInOp() == EOpCooperativeMatrixMulAdd); + + result->setType(result->getAsAggregate()->getSequence()[2]->getAsTyped()->getType()); + } } } @@ -1430,6 +1448,8 @@ TIntermTyped* TParseContext::handleLengthMethod(const TSourceLoc& loc, TFunction length = type.getMatrixCols(); else if (type.isVector()) length = type.getVectorSize(); + else if (type.isCoopMat()) + return intermediate.addBuiltInFunctionCall(loc, EOpArrayLength, true, intermNode, TType(EbtInt)); else { // we should not get here, because earlier semantic checking should have prevented this path error(loc, ".length()", "unexpected use of .length()", ""); @@ -1456,7 +1476,8 @@ void TParseContext::addInputArgumentConversions(const TFunction& function, TInte // means take 'arguments' itself as the one argument. TIntermTyped* arg = function.getParamCount() == 1 ? arguments->getAsTyped() : (aggregate ? aggregate->getSequence()[i]->getAsTyped() : arguments->getAsTyped()); if (*function[i].type != arg->getType()) { - if (function[i].type->getQualifier().isParamInput()) { + if (function[i].type->getQualifier().isParamInput() && + !function[i].type->isCoopMat()) { // In-qualified arguments just need an extra node added above the argument to // convert to the correct type. arg = intermediate.addConversion(EOpFunctionCall, *function[i].type, arg); @@ -1524,7 +1545,14 @@ TIntermTyped* TParseContext::addOutputArgumentConversions(const TFunction& funct if (function[i].type->getQualifier().isParamOutput()) { // Out-qualified arguments need to use the topology set up above. // do the " ...(tempArg, ...), arg = tempArg" bit from above - TVariable* tempArg = makeInternalVariable("tempArg", *function[i].type); + TType paramType; + paramType.shallowCopy(*function[i].type); + if (arguments[i]->getAsTyped()->getType().isParameterized() && + !paramType.isParameterized()) { + paramType.shallowCopy(arguments[i]->getAsTyped()->getType()); + paramType.copyTypeParameters(*arguments[i]->getAsTyped()->getType().getTypeParameters()); + } + TVariable* tempArg = makeInternalVariable("tempArg", paramType); tempArg->getWritableType().getQualifier().makeTemporary(); TIntermSymbol* tempArgNode = intermediate.addSymbol(*tempArg, intermNode.getLoc()); TIntermTyped* tempAssign = intermediate.addAssign(EOpAssign, arguments[i]->getAsTyped(), tempArgNode, arguments[i]->getLoc()); @@ -2913,6 +2941,16 @@ bool TParseContext::constructorError(const TSourceLoc& loc, TIntermNode* node, T return true; } + if (type.isCoopMat() && function.getParamCount() != 1) { + error(loc, "wrong number of arguments", "constructor", ""); + return true; + } + if (type.isCoopMat() && + !(function[0].type->isScalar() || function[0].type->isCoopMat())) { + error(loc, "Cooperative matrix constructor argument must be scalar or cooperative matrix", "constructor", ""); + return true; + } + TIntermTyped* typed = node->getAsTyped(); if (typed == nullptr) { error(loc, "constructor argument does not have a type", "constructor", ""); @@ -3534,7 +3572,7 @@ bool TParseContext::containsFieldWithBasicType(const TType& type, TBasicType bas // // Do size checking for an array type's size. // -void TParseContext::arraySizeCheck(const TSourceLoc& loc, TIntermTyped* expr, TArraySize& sizePair) +void TParseContext::arraySizeCheck(const TSourceLoc& loc, TIntermTyped* expr, TArraySize& sizePair, const char *sizeType) { bool isConst = false; sizePair.node = nullptr; @@ -3554,18 +3592,24 @@ void TParseContext::arraySizeCheck(const TSourceLoc& loc, TIntermTyped* expr, TA TIntermSymbol* symbol = expr->getAsSymbolNode(); if (symbol && symbol->getConstArray().size() > 0) size = symbol->getConstArray()[0].getIConst(); + } else if (expr->getAsUnaryNode() && + expr->getAsUnaryNode()->getOp() == glslang::EOpArrayLength && + expr->getAsUnaryNode()->getOperand()->getType().isCoopMat()) { + isConst = true; + size = 1; + sizePair.node = expr->getAsUnaryNode(); } } sizePair.size = size; if (! isConst || (expr->getBasicType() != EbtInt && expr->getBasicType() != EbtUint)) { - error(loc, "array size must be a constant integer expression", "", ""); + error(loc, sizeType, "", "must be a constant integer expression"); return; } if (size <= 0) { - error(loc, "array size must be a positive integer", "", ""); + error(loc, sizeType, "", "must be a positive integer"); return; } } @@ -3623,7 +3667,7 @@ bool TParseContext::arrayError(const TSourceLoc& loc, const TType& type) // void TParseContext::arraySizeRequiredCheck(const TSourceLoc& loc, const TArraySizes& arraySizes) { - if (arraySizes.hasUnsized()) + if (!parsingBuiltins && arraySizes.hasUnsized()) error(loc, "array size required", "", ""); } @@ -3660,7 +3704,8 @@ void TParseContext::arraySizesCheck(const TSourceLoc& loc, const TQualifier& qua arraySizes->clearInnerUnsized(); } - if (arraySizes->isInnerSpecialization()) + if (arraySizes->isInnerSpecialization() && + (qualifier.storage != EvqTemporary && qualifier.storage != EvqGlobal && qualifier.storage != EvqShared && qualifier.storage != EvqConst)) error(loc, "only outermost dimension of an array of arrays can be a specialization constant", "[]", ""); // desktop always allows outer-dimension-unsized variable arrays, @@ -6035,9 +6080,18 @@ const TFunction* TParseContext::findFunction400(const TSourceLoc& loc, const TFu symbolTable.findFunctionNameList(call.getMangledName(), candidateList, builtIn); // can 'from' convert to 'to'? - const auto convertible = [this](const TType& from, const TType& to, TOperator, int) -> bool { + const auto convertible = [this,builtIn](const TType& from, const TType& to, TOperator, int) -> bool { if (from == to) return true; + if (from.coopMatParameterOK(to)) + return true; + // Allow a sized array to be passed through an unsized array parameter, for coopMatLoad/Store functions + if (builtIn && from.isArray() && to.isUnsizedArray()) { + TType fromElementType(from, 0); + TType toElementType(to, 0); + if (fromElementType == toElementType) + return true; + } if (from.isArray() || to.isArray() || ! from.sameElementShape(to)) return false; return intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType()); @@ -6100,9 +6154,18 @@ const TFunction* TParseContext::findFunctionExplicitTypes(const TSourceLoc& loc, symbolTable.findFunctionNameList(call.getMangledName(), candidateList, builtIn); // can 'from' convert to 'to'? - const auto convertible = [this](const TType& from, const TType& to, TOperator, int) -> bool { + const auto convertible = [this,builtIn](const TType& from, const TType& to, TOperator, int) -> bool { if (from == to) return true; + if (from.coopMatParameterOK(to)) + return true; + // Allow a sized array to be passed through an unsized array parameter, for coopMatLoad/Store functions + if (builtIn && from.isArray() && to.isUnsizedArray()) { + TType fromElementType(from, 0); + TType toElementType(to, 0); + if (fromElementType == toElementType) + return true; + } if (from.isArray() || to.isArray() || ! from.sameElementShape(to)) return false; return intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType()); @@ -6194,6 +6257,25 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden type.copyArrayInnerSizes(publicType.arraySizes); arrayOfArrayVersionCheck(loc, type.getArraySizes()); + if (type.isCoopMat()) { + intermediate.setUseVulkanMemoryModel(); + intermediate.setUseStorageBuffer(); + + if (!publicType.typeParameters || publicType.typeParameters->getNumDims() != 4) { + error(loc, "expected four type parameters", identifier.c_str(), ""); + } + if (publicType.typeParameters && + publicType.typeParameters->getDimSize(0) != 16 && + publicType.typeParameters->getDimSize(0) != 32 && + publicType.typeParameters->getDimSize(0) != 64) { + error(loc, "expected 16, 32, or 64 bits for first type parameter", identifier.c_str(), ""); + } + } else { + if (publicType.typeParameters && publicType.typeParameters->getNumDims() != 0) { + error(loc, "unexpected type parameters", identifier.c_str(), ""); + } + } + if (voidErrorCheck(loc, identifier, type.getBasicType())) return nullptr; @@ -6218,6 +6300,10 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden requireInt8Arithmetic(loc, "qualifier", "(u)int8 types can only be in uniform block or buffer storage"); } + if (type.getQualifier().storage == EvqShared && + type.containsCoopMat()) + error(loc, "qualifier", "Cooperative matrix types must not be used in shared memory", ""); + if (identifier != "gl_FragCoord" && (publicType.shaderQualifiers.originUpperLeft || publicType.shaderQualifiers.pixelCenterInteger)) error(loc, "can only apply origin_upper_left and pixel_center_origin to gl_FragCoord", "layout qualifier", ""); if (identifier != "gl_FragDepth" && publicType.shaderQualifiers.layoutDepth != EldNone) @@ -6809,6 +6895,33 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T return nullptr; } + case EOpConstructCooperativeMatrix: + if (!node->getType().isCoopMat()) { + if (type.getBasicType() != node->getType().getBasicType()) { + node = intermediate.addConversion(type.getBasicType(), node); + } + node = intermediate.setAggregateOperator(node, EOpConstructCooperativeMatrix, type, node->getLoc()); + } else { + switch (type.getBasicType()) { + default: + assert(0); + break; + case EbtFloat: + assert(node->getType().getBasicType() == EbtFloat16); + node = intermediate.addUnaryNode(EOpConvFloat16ToFloat, node, node->getLoc(), type); + break; + case EbtFloat16: + assert(node->getType().getBasicType() == EbtFloat); + node = intermediate.addUnaryNode(EOpConvFloatToFloat16, node, node->getLoc(), type); + break; + } + // If it's a (non-specialization) constant, it must be folded. + if (node->getAsUnaryNode()->getOperand()->getAsConstantUnion()) + return node->getAsUnaryNode()->getOperand()->getAsConstantUnion()->fold(op, node->getType()); + } + + return node; + default: error(loc, "unsupported construction", "", ""); @@ -6895,6 +7008,9 @@ void TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeList, con if (memberType.containsOpaque()) error(memberLoc, "member of block cannot be or contain a sampler, image, or atomic_uint type", typeList[member].type->getFieldName().c_str(), ""); + + if (memberType.containsCoopMat()) + error(memberLoc, "member of block cannot be or contain a cooperative matrix type", typeList[member].type->getFieldName().c_str(), ""); } // This might be a redeclaration of a built-in block. If so, redeclareBuiltinBlock() will diff --git a/glslang/MachineIndependent/ParseHelper.h b/glslang/MachineIndependent/ParseHelper.h old mode 100755 new mode 100644 index f61345dc..0b21798c --- a/glslang/MachineIndependent/ParseHelper.h +++ b/glslang/MachineIndependent/ParseHelper.h @@ -337,7 +337,7 @@ public: void globalCheck(const TSourceLoc&, const char* token); bool constructorError(const TSourceLoc&, TIntermNode*, TFunction&, TOperator, TType&); bool constructorTextureSamplerError(const TSourceLoc&, const TFunction&); - void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&); + void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&, const char *sizeType); bool arrayQualifierError(const TSourceLoc&, const TQualifier&); bool arrayError(const TSourceLoc&, const TType&); void arraySizeRequiredCheck(const TSourceLoc&, const TArraySizes&); diff --git a/glslang/MachineIndependent/Scan.cpp b/glslang/MachineIndependent/Scan.cpp index 49ce0770..482f6ba2 100644 --- a/glslang/MachineIndependent/Scan.cpp +++ b/glslang/MachineIndependent/Scan.cpp @@ -714,6 +714,8 @@ void TScanContext::fillInKeywordMap() (*KeywordMap)["taskNV"] = PERTASKNV; #endif + (*KeywordMap)["fcoopmatNV"] = FCOOPMATNV; + ReservedSet = new std::unordered_set; ReservedSet->insert("common"); @@ -1612,6 +1614,13 @@ int TScanContext::tokenizeIdentifier() return identifierOrType(); #endif + case FCOOPMATNV: + afterType = true; + if (parseContext.symbolTable.atBuiltInLevel() || + parseContext.extensionTurnedOn(E_GL_NV_cooperative_matrix)) + return keyword; + return identifierOrType(); + default: parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc); return 0; diff --git a/glslang/MachineIndependent/Versions.cpp b/glslang/MachineIndependent/Versions.cpp old mode 100755 new mode 100644 index f78ffd0a..0d4b9946 --- a/glslang/MachineIndependent/Versions.cpp +++ b/glslang/MachineIndependent/Versions.cpp @@ -248,6 +248,8 @@ void TParseVersions::initializeExtensionBehavior() extensionBehavior[E_GL_NV_mesh_shader] = EBhDisable; #endif + extensionBehavior[E_GL_NV_cooperative_matrix] = EBhDisable; + // AEP extensionBehavior[E_GL_ANDROID_extension_pack_es31a] = EBhDisable; extensionBehavior[E_GL_KHR_blend_equation_advanced] = EBhDisable; @@ -427,6 +429,8 @@ void TParseVersions::getPreamble(std::string& preamble) "#define GL_NV_shader_texture_footprint 1\n" "#define GL_NV_mesh_shader 1\n" #endif + "#define GL_NV_cooperative_matrix 1\n" + "#define GL_EXT_shader_explicit_arithmetic_types 1\n" "#define GL_EXT_shader_explicit_arithmetic_types_int8 1\n" "#define GL_EXT_shader_explicit_arithmetic_types_int16 1\n" @@ -1083,6 +1087,14 @@ void TParseVersions::int64Check(const TSourceLoc& loc, const char* op, bool buil } } +void TParseVersions::fcoopmatCheck(const TSourceLoc& loc, const char* op, bool builtIn) +{ + if (!builtIn) { + const char* const extensions[] = {E_GL_NV_cooperative_matrix}; + requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op); + } +} + // Call for any operation removed because SPIR-V is in use. void TParseVersions::spvRemoved(const TSourceLoc& loc, const char* op) { diff --git a/glslang/MachineIndependent/Versions.h b/glslang/MachineIndependent/Versions.h index 72018d8e..e571b51c 100755 --- a/glslang/MachineIndependent/Versions.h +++ b/glslang/MachineIndependent/Versions.h @@ -225,6 +225,8 @@ const char* const viewportEXTs[] = { E_GL_ARB_shader_viewport_layer_array, E_GL_ const int Num_viewportEXTs = sizeof(viewportEXTs) / sizeof(viewportEXTs[0]); #endif +const char* const E_GL_NV_cooperative_matrix = "GL_NV_cooperative_matrix"; + // AEP const char* const E_GL_ANDROID_extension_pack_es31a = "GL_ANDROID_extension_pack_es31a"; const char* const E_GL_KHR_blend_equation_advanced = "GL_KHR_blend_equation_advanced"; diff --git a/glslang/MachineIndependent/glslang.y b/glslang/MachineIndependent/glslang.y old mode 100755 new mode 100644 index 90be7a79..92229d29 --- a/glslang/MachineIndependent/glslang.y +++ b/glslang/MachineIndependent/glslang.y @@ -100,6 +100,7 @@ using namespace glslang; glslang::TArraySizes* arraySizes; glslang::TIdentifierList* identifierList; }; + glslang::TArraySizes* typeParameters; } interm; } @@ -166,6 +167,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %token F64MAT4X2 F64MAT4X3 F64MAT4X4 %token ATOMIC_UINT %token ACCSTRUCTNV +%token FCOOPMATNV // combined image/sampler %token SAMPLER1D SAMPLER2D SAMPLER3D SAMPLERCUBE SAMPLER1DSHADOW SAMPLER2DSHADOW @@ -273,6 +275,10 @@ extern int yylex(YYSTYPE*, TParseContext&); %type layout_qualifier layout_qualifier_id_list layout_qualifier_id %type non_uniform_qualifier +%type type_parameter_specifier +%type type_parameter_specifier_opt +%type type_parameter_specifier_list + %type type_qualifier fully_specified_type type_specifier %type single_type_qualifier %type type_specifier_nonarray @@ -1487,15 +1493,17 @@ type_name_list ; type_specifier - : type_specifier_nonarray { + : type_specifier_nonarray type_parameter_specifier_opt { $$ = $1; $$.qualifier.precision = parseContext.getDefaultPrecision($$); + $$.typeParameters = $2; } - | type_specifier_nonarray array_specifier { - parseContext.arrayOfArrayVersionCheck($2.loc, $2.arraySizes); + | type_specifier_nonarray type_parameter_specifier_opt array_specifier { + parseContext.arrayOfArrayVersionCheck($3.loc, $3.arraySizes); $$ = $1; $$.qualifier.precision = parseContext.getDefaultPrecision($$); - $$.arraySizes = $2.arraySizes; + $$.typeParameters = $2; + $$.arraySizes = $3.arraySizes; } ; @@ -1510,7 +1518,7 @@ array_specifier $$.arraySizes = new TArraySizes; TArraySize size; - parseContext.arraySizeCheck($2->getLoc(), $2, size); + parseContext.arraySizeCheck($2->getLoc(), $2, size, "array size"); $$.arraySizes->addInnerSize(size); } | array_specifier LEFT_BRACKET RIGHT_BRACKET { @@ -1521,11 +1529,43 @@ array_specifier $$ = $1; TArraySize size; - parseContext.arraySizeCheck($3->getLoc(), $3, size); + parseContext.arraySizeCheck($3->getLoc(), $3, size, "array size"); $$.arraySizes->addInnerSize(size); } ; +type_parameter_specifier_opt + : type_parameter_specifier { + $$ = $1; + } + | /* May be null */ { + $$ = 0; + } + ; + +type_parameter_specifier + : LEFT_ANGLE type_parameter_specifier_list RIGHT_ANGLE { + $$ = $2; + } + ; + +type_parameter_specifier_list + : unary_expression { + $$ = new TArraySizes; + + TArraySize size; + parseContext.arraySizeCheck($1->getLoc(), $1, size, "type parameter"); + $$->addInnerSize(size); + } + | type_parameter_specifier_list COMMA unary_expression { + $$ = $1; + + TArraySize size; + parseContext.arraySizeCheck($3->getLoc(), $3, size, "type parameter"); + $$->addInnerSize(size); + } + ; + type_specifier_nonarray : VOID { $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); @@ -3172,6 +3212,12 @@ type_specifier_nonarray $$.basicType = EbtSampler; $$.sampler.setSubpass(EbtUint, true); } + | FCOOPMATNV { + parseContext.fcoopmatCheck($1.loc, "fcoopmatNV", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtFloat; + $$.coopmat = true; + } | struct_specifier { $$ = $1; $$.qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary; diff --git a/glslang/MachineIndependent/glslang_tab.cpp b/glslang/MachineIndependent/glslang_tab.cpp index 6a2eb402..0ab355f1 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp +++ b/glslang/MachineIndependent/glslang_tab.cpp @@ -298,235 +298,236 @@ extern int yydebug; F64MAT4X4 = 430, ATOMIC_UINT = 431, ACCSTRUCTNV = 432, - SAMPLER1D = 433, - SAMPLER2D = 434, - SAMPLER3D = 435, - SAMPLERCUBE = 436, - SAMPLER1DSHADOW = 437, - SAMPLER2DSHADOW = 438, - SAMPLERCUBESHADOW = 439, - SAMPLER1DARRAY = 440, - SAMPLER2DARRAY = 441, - SAMPLER1DARRAYSHADOW = 442, - SAMPLER2DARRAYSHADOW = 443, - ISAMPLER1D = 444, - ISAMPLER2D = 445, - ISAMPLER3D = 446, - ISAMPLERCUBE = 447, - ISAMPLER1DARRAY = 448, - ISAMPLER2DARRAY = 449, - USAMPLER1D = 450, - USAMPLER2D = 451, - USAMPLER3D = 452, - USAMPLERCUBE = 453, - USAMPLER1DARRAY = 454, - USAMPLER2DARRAY = 455, - SAMPLER2DRECT = 456, - SAMPLER2DRECTSHADOW = 457, - ISAMPLER2DRECT = 458, - USAMPLER2DRECT = 459, - SAMPLERBUFFER = 460, - ISAMPLERBUFFER = 461, - USAMPLERBUFFER = 462, - SAMPLERCUBEARRAY = 463, - SAMPLERCUBEARRAYSHADOW = 464, - ISAMPLERCUBEARRAY = 465, - USAMPLERCUBEARRAY = 466, - SAMPLER2DMS = 467, - ISAMPLER2DMS = 468, - USAMPLER2DMS = 469, - SAMPLER2DMSARRAY = 470, - ISAMPLER2DMSARRAY = 471, - USAMPLER2DMSARRAY = 472, - SAMPLEREXTERNALOES = 473, - SAMPLEREXTERNAL2DY2YEXT = 474, - F16SAMPLER1D = 475, - F16SAMPLER2D = 476, - F16SAMPLER3D = 477, - F16SAMPLER2DRECT = 478, - F16SAMPLERCUBE = 479, - F16SAMPLER1DARRAY = 480, - F16SAMPLER2DARRAY = 481, - F16SAMPLERCUBEARRAY = 482, - F16SAMPLERBUFFER = 483, - F16SAMPLER2DMS = 484, - F16SAMPLER2DMSARRAY = 485, - F16SAMPLER1DSHADOW = 486, - F16SAMPLER2DSHADOW = 487, - F16SAMPLER1DARRAYSHADOW = 488, - F16SAMPLER2DARRAYSHADOW = 489, - F16SAMPLER2DRECTSHADOW = 490, - F16SAMPLERCUBESHADOW = 491, - F16SAMPLERCUBEARRAYSHADOW = 492, - SAMPLER = 493, - SAMPLERSHADOW = 494, - TEXTURE1D = 495, - TEXTURE2D = 496, - TEXTURE3D = 497, - TEXTURECUBE = 498, - TEXTURE1DARRAY = 499, - TEXTURE2DARRAY = 500, - ITEXTURE1D = 501, - ITEXTURE2D = 502, - ITEXTURE3D = 503, - ITEXTURECUBE = 504, - ITEXTURE1DARRAY = 505, - ITEXTURE2DARRAY = 506, - UTEXTURE1D = 507, - UTEXTURE2D = 508, - UTEXTURE3D = 509, - UTEXTURECUBE = 510, - UTEXTURE1DARRAY = 511, - UTEXTURE2DARRAY = 512, - TEXTURE2DRECT = 513, - ITEXTURE2DRECT = 514, - UTEXTURE2DRECT = 515, - TEXTUREBUFFER = 516, - ITEXTUREBUFFER = 517, - UTEXTUREBUFFER = 518, - TEXTURECUBEARRAY = 519, - ITEXTURECUBEARRAY = 520, - UTEXTURECUBEARRAY = 521, - TEXTURE2DMS = 522, - ITEXTURE2DMS = 523, - UTEXTURE2DMS = 524, - TEXTURE2DMSARRAY = 525, - ITEXTURE2DMSARRAY = 526, - UTEXTURE2DMSARRAY = 527, - F16TEXTURE1D = 528, - F16TEXTURE2D = 529, - F16TEXTURE3D = 530, - F16TEXTURE2DRECT = 531, - F16TEXTURECUBE = 532, - F16TEXTURE1DARRAY = 533, - F16TEXTURE2DARRAY = 534, - F16TEXTURECUBEARRAY = 535, - F16TEXTUREBUFFER = 536, - F16TEXTURE2DMS = 537, - F16TEXTURE2DMSARRAY = 538, - SUBPASSINPUT = 539, - SUBPASSINPUTMS = 540, - ISUBPASSINPUT = 541, - ISUBPASSINPUTMS = 542, - USUBPASSINPUT = 543, - USUBPASSINPUTMS = 544, - F16SUBPASSINPUT = 545, - F16SUBPASSINPUTMS = 546, - IMAGE1D = 547, - IIMAGE1D = 548, - UIMAGE1D = 549, - IMAGE2D = 550, - IIMAGE2D = 551, - UIMAGE2D = 552, - IMAGE3D = 553, - IIMAGE3D = 554, - UIMAGE3D = 555, - IMAGE2DRECT = 556, - IIMAGE2DRECT = 557, - UIMAGE2DRECT = 558, - IMAGECUBE = 559, - IIMAGECUBE = 560, - UIMAGECUBE = 561, - IMAGEBUFFER = 562, - IIMAGEBUFFER = 563, - UIMAGEBUFFER = 564, - IMAGE1DARRAY = 565, - IIMAGE1DARRAY = 566, - UIMAGE1DARRAY = 567, - IMAGE2DARRAY = 568, - IIMAGE2DARRAY = 569, - UIMAGE2DARRAY = 570, - IMAGECUBEARRAY = 571, - IIMAGECUBEARRAY = 572, - UIMAGECUBEARRAY = 573, - IMAGE2DMS = 574, - IIMAGE2DMS = 575, - UIMAGE2DMS = 576, - IMAGE2DMSARRAY = 577, - IIMAGE2DMSARRAY = 578, - UIMAGE2DMSARRAY = 579, - F16IMAGE1D = 580, - F16IMAGE2D = 581, - F16IMAGE3D = 582, - F16IMAGE2DRECT = 583, - F16IMAGECUBE = 584, - F16IMAGE1DARRAY = 585, - F16IMAGE2DARRAY = 586, - F16IMAGECUBEARRAY = 587, - F16IMAGEBUFFER = 588, - F16IMAGE2DMS = 589, - F16IMAGE2DMSARRAY = 590, - STRUCT = 591, - VOID = 592, - WHILE = 593, - IDENTIFIER = 594, - TYPE_NAME = 595, - FLOATCONSTANT = 596, - DOUBLECONSTANT = 597, - INT16CONSTANT = 598, - UINT16CONSTANT = 599, - INT32CONSTANT = 600, - UINT32CONSTANT = 601, - INTCONSTANT = 602, - UINTCONSTANT = 603, - INT64CONSTANT = 604, - UINT64CONSTANT = 605, - BOOLCONSTANT = 606, - FLOAT16CONSTANT = 607, - LEFT_OP = 608, - RIGHT_OP = 609, - INC_OP = 610, - DEC_OP = 611, - LE_OP = 612, - GE_OP = 613, - EQ_OP = 614, - NE_OP = 615, - AND_OP = 616, - OR_OP = 617, - XOR_OP = 618, - MUL_ASSIGN = 619, - DIV_ASSIGN = 620, - ADD_ASSIGN = 621, - MOD_ASSIGN = 622, - LEFT_ASSIGN = 623, - RIGHT_ASSIGN = 624, - AND_ASSIGN = 625, - XOR_ASSIGN = 626, - OR_ASSIGN = 627, - SUB_ASSIGN = 628, - LEFT_PAREN = 629, - RIGHT_PAREN = 630, - LEFT_BRACKET = 631, - RIGHT_BRACKET = 632, - LEFT_BRACE = 633, - RIGHT_BRACE = 634, - DOT = 635, - COMMA = 636, - COLON = 637, - EQUAL = 638, - SEMICOLON = 639, - BANG = 640, - DASH = 641, - TILDE = 642, - PLUS = 643, - STAR = 644, - SLASH = 645, - PERCENT = 646, - LEFT_ANGLE = 647, - RIGHT_ANGLE = 648, - VERTICAL_BAR = 649, - CARET = 650, - AMPERSAND = 651, - QUESTION = 652, - INVARIANT = 653, - PRECISE = 654, - HIGH_PRECISION = 655, - MEDIUM_PRECISION = 656, - LOW_PRECISION = 657, - PRECISION = 658, - PACKED = 659, - RESOURCE = 660, - SUPERP = 661 + FCOOPMATNV = 433, + SAMPLER1D = 434, + SAMPLER2D = 435, + SAMPLER3D = 436, + SAMPLERCUBE = 437, + SAMPLER1DSHADOW = 438, + SAMPLER2DSHADOW = 439, + SAMPLERCUBESHADOW = 440, + SAMPLER1DARRAY = 441, + SAMPLER2DARRAY = 442, + SAMPLER1DARRAYSHADOW = 443, + SAMPLER2DARRAYSHADOW = 444, + ISAMPLER1D = 445, + ISAMPLER2D = 446, + ISAMPLER3D = 447, + ISAMPLERCUBE = 448, + ISAMPLER1DARRAY = 449, + ISAMPLER2DARRAY = 450, + USAMPLER1D = 451, + USAMPLER2D = 452, + USAMPLER3D = 453, + USAMPLERCUBE = 454, + USAMPLER1DARRAY = 455, + USAMPLER2DARRAY = 456, + SAMPLER2DRECT = 457, + SAMPLER2DRECTSHADOW = 458, + ISAMPLER2DRECT = 459, + USAMPLER2DRECT = 460, + SAMPLERBUFFER = 461, + ISAMPLERBUFFER = 462, + USAMPLERBUFFER = 463, + SAMPLERCUBEARRAY = 464, + SAMPLERCUBEARRAYSHADOW = 465, + ISAMPLERCUBEARRAY = 466, + USAMPLERCUBEARRAY = 467, + SAMPLER2DMS = 468, + ISAMPLER2DMS = 469, + USAMPLER2DMS = 470, + SAMPLER2DMSARRAY = 471, + ISAMPLER2DMSARRAY = 472, + USAMPLER2DMSARRAY = 473, + SAMPLEREXTERNALOES = 474, + SAMPLEREXTERNAL2DY2YEXT = 475, + F16SAMPLER1D = 476, + F16SAMPLER2D = 477, + F16SAMPLER3D = 478, + F16SAMPLER2DRECT = 479, + F16SAMPLERCUBE = 480, + F16SAMPLER1DARRAY = 481, + F16SAMPLER2DARRAY = 482, + F16SAMPLERCUBEARRAY = 483, + F16SAMPLERBUFFER = 484, + F16SAMPLER2DMS = 485, + F16SAMPLER2DMSARRAY = 486, + F16SAMPLER1DSHADOW = 487, + F16SAMPLER2DSHADOW = 488, + F16SAMPLER1DARRAYSHADOW = 489, + F16SAMPLER2DARRAYSHADOW = 490, + F16SAMPLER2DRECTSHADOW = 491, + F16SAMPLERCUBESHADOW = 492, + F16SAMPLERCUBEARRAYSHADOW = 493, + SAMPLER = 494, + SAMPLERSHADOW = 495, + TEXTURE1D = 496, + TEXTURE2D = 497, + TEXTURE3D = 498, + TEXTURECUBE = 499, + TEXTURE1DARRAY = 500, + TEXTURE2DARRAY = 501, + ITEXTURE1D = 502, + ITEXTURE2D = 503, + ITEXTURE3D = 504, + ITEXTURECUBE = 505, + ITEXTURE1DARRAY = 506, + ITEXTURE2DARRAY = 507, + UTEXTURE1D = 508, + UTEXTURE2D = 509, + UTEXTURE3D = 510, + UTEXTURECUBE = 511, + UTEXTURE1DARRAY = 512, + UTEXTURE2DARRAY = 513, + TEXTURE2DRECT = 514, + ITEXTURE2DRECT = 515, + UTEXTURE2DRECT = 516, + TEXTUREBUFFER = 517, + ITEXTUREBUFFER = 518, + UTEXTUREBUFFER = 519, + TEXTURECUBEARRAY = 520, + ITEXTURECUBEARRAY = 521, + UTEXTURECUBEARRAY = 522, + TEXTURE2DMS = 523, + ITEXTURE2DMS = 524, + UTEXTURE2DMS = 525, + TEXTURE2DMSARRAY = 526, + ITEXTURE2DMSARRAY = 527, + UTEXTURE2DMSARRAY = 528, + F16TEXTURE1D = 529, + F16TEXTURE2D = 530, + F16TEXTURE3D = 531, + F16TEXTURE2DRECT = 532, + F16TEXTURECUBE = 533, + F16TEXTURE1DARRAY = 534, + F16TEXTURE2DARRAY = 535, + F16TEXTURECUBEARRAY = 536, + F16TEXTUREBUFFER = 537, + F16TEXTURE2DMS = 538, + F16TEXTURE2DMSARRAY = 539, + SUBPASSINPUT = 540, + SUBPASSINPUTMS = 541, + ISUBPASSINPUT = 542, + ISUBPASSINPUTMS = 543, + USUBPASSINPUT = 544, + USUBPASSINPUTMS = 545, + F16SUBPASSINPUT = 546, + F16SUBPASSINPUTMS = 547, + IMAGE1D = 548, + IIMAGE1D = 549, + UIMAGE1D = 550, + IMAGE2D = 551, + IIMAGE2D = 552, + UIMAGE2D = 553, + IMAGE3D = 554, + IIMAGE3D = 555, + UIMAGE3D = 556, + IMAGE2DRECT = 557, + IIMAGE2DRECT = 558, + UIMAGE2DRECT = 559, + IMAGECUBE = 560, + IIMAGECUBE = 561, + UIMAGECUBE = 562, + IMAGEBUFFER = 563, + IIMAGEBUFFER = 564, + UIMAGEBUFFER = 565, + IMAGE1DARRAY = 566, + IIMAGE1DARRAY = 567, + UIMAGE1DARRAY = 568, + IMAGE2DARRAY = 569, + IIMAGE2DARRAY = 570, + UIMAGE2DARRAY = 571, + IMAGECUBEARRAY = 572, + IIMAGECUBEARRAY = 573, + UIMAGECUBEARRAY = 574, + IMAGE2DMS = 575, + IIMAGE2DMS = 576, + UIMAGE2DMS = 577, + IMAGE2DMSARRAY = 578, + IIMAGE2DMSARRAY = 579, + UIMAGE2DMSARRAY = 580, + F16IMAGE1D = 581, + F16IMAGE2D = 582, + F16IMAGE3D = 583, + F16IMAGE2DRECT = 584, + F16IMAGECUBE = 585, + F16IMAGE1DARRAY = 586, + F16IMAGE2DARRAY = 587, + F16IMAGECUBEARRAY = 588, + F16IMAGEBUFFER = 589, + F16IMAGE2DMS = 590, + F16IMAGE2DMSARRAY = 591, + STRUCT = 592, + VOID = 593, + WHILE = 594, + IDENTIFIER = 595, + TYPE_NAME = 596, + FLOATCONSTANT = 597, + DOUBLECONSTANT = 598, + INT16CONSTANT = 599, + UINT16CONSTANT = 600, + INT32CONSTANT = 601, + UINT32CONSTANT = 602, + INTCONSTANT = 603, + UINTCONSTANT = 604, + INT64CONSTANT = 605, + UINT64CONSTANT = 606, + BOOLCONSTANT = 607, + FLOAT16CONSTANT = 608, + LEFT_OP = 609, + RIGHT_OP = 610, + INC_OP = 611, + DEC_OP = 612, + LE_OP = 613, + GE_OP = 614, + EQ_OP = 615, + NE_OP = 616, + AND_OP = 617, + OR_OP = 618, + XOR_OP = 619, + MUL_ASSIGN = 620, + DIV_ASSIGN = 621, + ADD_ASSIGN = 622, + MOD_ASSIGN = 623, + LEFT_ASSIGN = 624, + RIGHT_ASSIGN = 625, + AND_ASSIGN = 626, + XOR_ASSIGN = 627, + OR_ASSIGN = 628, + SUB_ASSIGN = 629, + LEFT_PAREN = 630, + RIGHT_PAREN = 631, + LEFT_BRACKET = 632, + RIGHT_BRACKET = 633, + LEFT_BRACE = 634, + RIGHT_BRACE = 635, + DOT = 636, + COMMA = 637, + COLON = 638, + EQUAL = 639, + SEMICOLON = 640, + BANG = 641, + DASH = 642, + TILDE = 643, + PLUS = 644, + STAR = 645, + SLASH = 646, + PERCENT = 647, + LEFT_ANGLE = 648, + RIGHT_ANGLE = 649, + VERTICAL_BAR = 650, + CARET = 651, + AMPERSAND = 652, + QUESTION = 653, + INVARIANT = 654, + PRECISE = 655, + HIGH_PRECISION = 656, + MEDIUM_PRECISION = 657, + LOW_PRECISION = 658, + PRECISION = 659, + PACKED = 660, + RESOURCE = 661, + SUPERP = 662 }; #endif @@ -568,9 +569,10 @@ union YYSTYPE glslang::TArraySizes* arraySizes; glslang::TIdentifierList* identifierList; }; + glslang::TArraySizes* typeParameters; } interm; -#line 574 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355 */ +#line 576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355 */ }; typedef union YYSTYPE YYSTYPE; @@ -585,7 +587,7 @@ int yyparse (glslang::TParseContext* pParseContext); #endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED */ /* Copy the second part of user declarations. */ -#line 106 "MachineIndependent/glslang.y" /* yacc.c:358 */ +#line 107 "MachineIndependent/glslang.y" /* yacc.c:358 */ /* windows only pragma */ @@ -601,7 +603,7 @@ int yyparse (glslang::TParseContext* pParseContext); extern int yylex(YYSTYPE*, TParseContext&); -#line 605 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358 */ +#line 607 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358 */ #ifdef short # undef short @@ -841,23 +843,23 @@ union yyalloc #endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ -#define YYFINAL 382 +#define YYFINAL 384 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 9317 +#define YYLAST 9348 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 407 +#define YYNTOKENS 408 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 107 +#define YYNNTS 110 /* YYNRULES -- Number of rules. */ -#define YYNRULES 572 +#define YYNRULES 578 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 713 +#define YYNSTATES 722 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 661 +#define YYMAXUTOK 662 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) @@ -932,71 +934,71 @@ static const yytype_uint16 yytranslate[] = 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406 + 405, 406, 407 }; #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { - 0, 296, 296, 302, 305, 309, 313, 316, 320, 324, - 328, 332, 336, 339, 343, 347, 350, 358, 361, 364, - 367, 370, 375, 383, 390, 397, 403, 407, 414, 417, - 423, 430, 440, 448, 453, 480, 488, 494, 498, 502, - 522, 523, 524, 525, 531, 532, 537, 542, 551, 552, - 557, 565, 566, 572, 581, 582, 587, 592, 597, 605, - 606, 614, 625, 626, 635, 636, 645, 646, 655, 656, - 664, 665, 673, 674, 682, 683, 683, 701, 702, 718, - 722, 726, 730, 735, 739, 743, 747, 751, 755, 759, - 766, 769, 780, 787, 792, 797, 805, 809, 813, 817, - 822, 827, 836, 836, 847, 851, 858, 865, 868, 875, - 883, 903, 926, 941, 966, 977, 987, 997, 1007, 1016, - 1019, 1023, 1027, 1032, 1040, 1045, 1050, 1055, 1060, 1069, - 1080, 1107, 1116, 1123, 1130, 1141, 1150, 1160, 1172, 1181, - 1193, 1199, 1202, 1209, 1213, 1217, 1225, 1234, 1237, 1248, - 1251, 1254, 1258, 1262, 1266, 1270, 1276, 1280, 1292, 1306, - 1311, 1317, 1323, 1330, 1336, 1341, 1346, 1351, 1361, 1371, - 1381, 1391, 1400, 1412, 1416, 1421, 1426, 1431, 1436, 1441, - 1445, 1449, 1453, 1457, 1463, 1472, 1479, 1482, 1490, 1494, - 1503, 1508, 1516, 1520, 1530, 1534, 1538, 1543, 1548, 1553, - 1558, 1562, 1567, 1572, 1577, 1582, 1587, 1592, 1597, 1602, - 1607, 1611, 1616, 1621, 1626, 1632, 1638, 1644, 1650, 1656, - 1662, 1668, 1674, 1680, 1686, 1692, 1698, 1703, 1708, 1713, - 1718, 1723, 1728, 1734, 1740, 1746, 1752, 1758, 1764, 1770, - 1776, 1782, 1788, 1794, 1800, 1806, 1812, 1818, 1824, 1830, - 1836, 1842, 1848, 1854, 1860, 1866, 1872, 1878, 1884, 1890, - 1895, 1900, 1905, 1910, 1915, 1920, 1925, 1930, 1935, 1940, - 1945, 1950, 1956, 1962, 1968, 1974, 1980, 1986, 1992, 1998, - 2004, 2010, 2016, 2022, 2028, 2034, 2040, 2046, 2052, 2058, - 2064, 2070, 2076, 2082, 2088, 2094, 2100, 2106, 2112, 2118, - 2124, 2130, 2136, 2142, 2148, 2154, 2160, 2166, 2172, 2178, - 2184, 2190, 2196, 2202, 2208, 2214, 2220, 2226, 2232, 2238, - 2244, 2249, 2254, 2259, 2264, 2269, 2274, 2279, 2284, 2289, - 2294, 2299, 2304, 2309, 2314, 2322, 2330, 2338, 2346, 2354, - 2362, 2370, 2378, 2386, 2394, 2402, 2410, 2418, 2423, 2428, - 2433, 2438, 2443, 2448, 2453, 2458, 2463, 2468, 2473, 2478, - 2483, 2488, 2493, 2498, 2506, 2514, 2519, 2524, 2529, 2537, - 2542, 2547, 2552, 2560, 2565, 2570, 2575, 2583, 2588, 2593, - 2598, 2603, 2608, 2616, 2621, 2629, 2634, 2642, 2647, 2655, - 2660, 2668, 2673, 2681, 2686, 2694, 2699, 2704, 2709, 2714, - 2719, 2724, 2729, 2734, 2739, 2744, 2749, 2754, 2759, 2764, - 2769, 2777, 2782, 2787, 2792, 2800, 2805, 2810, 2815, 2823, - 2828, 2833, 2838, 2846, 2851, 2856, 2861, 2869, 2874, 2879, - 2884, 2892, 2897, 2902, 2907, 2915, 2920, 2925, 2930, 2938, - 2943, 2948, 2953, 2961, 2966, 2971, 2976, 2984, 2989, 2994, - 2999, 3007, 3012, 3017, 3022, 3030, 3035, 3040, 3045, 3053, - 3058, 3063, 3068, 3076, 3081, 3086, 3091, 3099, 3104, 3109, - 3115, 3121, 3127, 3133, 3142, 3151, 3157, 3163, 3169, 3175, - 3180, 3196, 3201, 3206, 3214, 3214, 3225, 3225, 3235, 3238, - 3251, 3273, 3300, 3304, 3310, 3315, 3326, 3329, 3335, 3344, - 3347, 3353, 3357, 3358, 3364, 3365, 3366, 3367, 3368, 3369, - 3370, 3374, 3375, 3379, 3375, 3391, 3392, 3396, 3396, 3403, - 3403, 3417, 3420, 3428, 3436, 3447, 3448, 3452, 3455, 3461, - 3468, 3472, 3480, 3484, 3497, 3500, 3506, 3506, 3526, 3529, - 3535, 3547, 3559, 3562, 3568, 3568, 3583, 3583, 3599, 3599, - 3620, 3623, 3629, 3632, 3638, 3642, 3649, 3654, 3659, 3666, - 3669, 3678, 3682, 3691, 3694, 3697, 3705, 3705, 3727, 3733, - 3736, 3741, 3744 + 0, 302, 302, 308, 311, 315, 319, 322, 326, 330, + 334, 338, 342, 345, 349, 353, 356, 364, 367, 370, + 373, 376, 381, 389, 396, 403, 409, 413, 420, 423, + 429, 436, 446, 454, 459, 486, 494, 500, 504, 508, + 528, 529, 530, 531, 537, 538, 543, 548, 557, 558, + 563, 571, 572, 578, 587, 588, 593, 598, 603, 611, + 612, 620, 631, 632, 641, 642, 651, 652, 661, 662, + 670, 671, 679, 680, 688, 689, 689, 707, 708, 724, + 728, 732, 736, 741, 745, 749, 753, 757, 761, 765, + 772, 775, 786, 793, 798, 803, 811, 815, 819, 823, + 828, 833, 842, 842, 853, 857, 864, 871, 874, 881, + 889, 909, 932, 947, 972, 983, 993, 1003, 1013, 1022, + 1025, 1029, 1033, 1038, 1046, 1051, 1056, 1061, 1066, 1075, + 1086, 1113, 1122, 1129, 1136, 1147, 1156, 1166, 1178, 1187, + 1199, 1205, 1208, 1215, 1219, 1223, 1231, 1240, 1243, 1254, + 1257, 1260, 1264, 1268, 1272, 1276, 1282, 1286, 1298, 1312, + 1317, 1323, 1329, 1336, 1342, 1347, 1352, 1357, 1367, 1377, + 1387, 1397, 1406, 1418, 1422, 1427, 1432, 1437, 1442, 1447, + 1451, 1455, 1459, 1463, 1469, 1478, 1485, 1488, 1496, 1501, + 1511, 1516, 1524, 1528, 1538, 1541, 1547, 1553, 1560, 1570, + 1574, 1578, 1583, 1588, 1593, 1598, 1602, 1607, 1612, 1617, + 1622, 1627, 1632, 1637, 1642, 1647, 1651, 1656, 1661, 1666, + 1672, 1678, 1684, 1690, 1696, 1702, 1708, 1714, 1720, 1726, + 1732, 1738, 1743, 1748, 1753, 1758, 1763, 1768, 1774, 1780, + 1786, 1792, 1798, 1804, 1810, 1816, 1822, 1828, 1834, 1840, + 1846, 1852, 1858, 1864, 1870, 1876, 1882, 1888, 1894, 1900, + 1906, 1912, 1918, 1924, 1930, 1935, 1940, 1945, 1950, 1955, + 1960, 1965, 1970, 1975, 1980, 1985, 1990, 1996, 2002, 2008, + 2014, 2020, 2026, 2032, 2038, 2044, 2050, 2056, 2062, 2068, + 2074, 2080, 2086, 2092, 2098, 2104, 2110, 2116, 2122, 2128, + 2134, 2140, 2146, 2152, 2158, 2164, 2170, 2176, 2182, 2188, + 2194, 2200, 2206, 2212, 2218, 2224, 2230, 2236, 2242, 2248, + 2254, 2260, 2266, 2272, 2278, 2284, 2289, 2294, 2299, 2304, + 2309, 2314, 2319, 2324, 2329, 2334, 2339, 2344, 2349, 2354, + 2362, 2370, 2378, 2386, 2394, 2402, 2410, 2418, 2426, 2434, + 2442, 2450, 2458, 2463, 2468, 2473, 2478, 2483, 2488, 2493, + 2498, 2503, 2508, 2513, 2518, 2523, 2528, 2533, 2538, 2546, + 2554, 2559, 2564, 2569, 2577, 2582, 2587, 2592, 2600, 2605, + 2610, 2615, 2623, 2628, 2633, 2638, 2643, 2648, 2656, 2661, + 2669, 2674, 2682, 2687, 2695, 2700, 2708, 2713, 2721, 2726, + 2734, 2739, 2744, 2749, 2754, 2759, 2764, 2769, 2774, 2779, + 2784, 2789, 2794, 2799, 2804, 2809, 2817, 2822, 2827, 2832, + 2840, 2845, 2850, 2855, 2863, 2868, 2873, 2878, 2886, 2891, + 2896, 2901, 2909, 2914, 2919, 2924, 2932, 2937, 2942, 2947, + 2955, 2960, 2965, 2970, 2978, 2983, 2988, 2993, 3001, 3006, + 3011, 3016, 3024, 3029, 3034, 3039, 3047, 3052, 3057, 3062, + 3070, 3075, 3080, 3085, 3093, 3098, 3103, 3108, 3116, 3121, + 3126, 3131, 3139, 3144, 3149, 3155, 3161, 3167, 3173, 3182, + 3191, 3197, 3203, 3209, 3215, 3221, 3226, 3242, 3247, 3252, + 3260, 3260, 3271, 3271, 3281, 3284, 3297, 3319, 3346, 3350, + 3356, 3361, 3372, 3375, 3381, 3390, 3393, 3399, 3403, 3404, + 3410, 3411, 3412, 3413, 3414, 3415, 3416, 3420, 3421, 3425, + 3421, 3437, 3438, 3442, 3442, 3449, 3449, 3463, 3466, 3474, + 3482, 3493, 3494, 3498, 3501, 3507, 3514, 3518, 3526, 3530, + 3543, 3546, 3552, 3552, 3572, 3575, 3581, 3593, 3605, 3608, + 3614, 3614, 3629, 3629, 3645, 3645, 3666, 3669, 3675, 3678, + 3684, 3688, 3695, 3700, 3705, 3712, 3715, 3724, 3728, 3737, + 3740, 3743, 3751, 3751, 3773, 3779, 3782, 3787, 3790 }; #endif @@ -1035,48 +1037,49 @@ static const char *const yytname[] = "F32MAT3X4", "F32MAT4X2", "F32MAT4X3", "F32MAT4X4", "F64MAT2X2", "F64MAT2X3", "F64MAT2X4", "F64MAT3X2", "F64MAT3X3", "F64MAT3X4", "F64MAT4X2", "F64MAT4X3", "F64MAT4X4", "ATOMIC_UINT", "ACCSTRUCTNV", - "SAMPLER1D", "SAMPLER2D", "SAMPLER3D", "SAMPLERCUBE", "SAMPLER1DSHADOW", - "SAMPLER2DSHADOW", "SAMPLERCUBESHADOW", "SAMPLER1DARRAY", - "SAMPLER2DARRAY", "SAMPLER1DARRAYSHADOW", "SAMPLER2DARRAYSHADOW", - "ISAMPLER1D", "ISAMPLER2D", "ISAMPLER3D", "ISAMPLERCUBE", - "ISAMPLER1DARRAY", "ISAMPLER2DARRAY", "USAMPLER1D", "USAMPLER2D", - "USAMPLER3D", "USAMPLERCUBE", "USAMPLER1DARRAY", "USAMPLER2DARRAY", - "SAMPLER2DRECT", "SAMPLER2DRECTSHADOW", "ISAMPLER2DRECT", - "USAMPLER2DRECT", "SAMPLERBUFFER", "ISAMPLERBUFFER", "USAMPLERBUFFER", - "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY", - "USAMPLERCUBEARRAY", "SAMPLER2DMS", "ISAMPLER2DMS", "USAMPLER2DMS", - "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY", "USAMPLER2DMSARRAY", - "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT", "F16SAMPLER1D", - "F16SAMPLER2D", "F16SAMPLER3D", "F16SAMPLER2DRECT", "F16SAMPLERCUBE", - "F16SAMPLER1DARRAY", "F16SAMPLER2DARRAY", "F16SAMPLERCUBEARRAY", - "F16SAMPLERBUFFER", "F16SAMPLER2DMS", "F16SAMPLER2DMSARRAY", - "F16SAMPLER1DSHADOW", "F16SAMPLER2DSHADOW", "F16SAMPLER1DARRAYSHADOW", - "F16SAMPLER2DARRAYSHADOW", "F16SAMPLER2DRECTSHADOW", - "F16SAMPLERCUBESHADOW", "F16SAMPLERCUBEARRAYSHADOW", "SAMPLER", - "SAMPLERSHADOW", "TEXTURE1D", "TEXTURE2D", "TEXTURE3D", "TEXTURECUBE", - "TEXTURE1DARRAY", "TEXTURE2DARRAY", "ITEXTURE1D", "ITEXTURE2D", - "ITEXTURE3D", "ITEXTURECUBE", "ITEXTURE1DARRAY", "ITEXTURE2DARRAY", - "UTEXTURE1D", "UTEXTURE2D", "UTEXTURE3D", "UTEXTURECUBE", - "UTEXTURE1DARRAY", "UTEXTURE2DARRAY", "TEXTURE2DRECT", "ITEXTURE2DRECT", - "UTEXTURE2DRECT", "TEXTUREBUFFER", "ITEXTUREBUFFER", "UTEXTUREBUFFER", - "TEXTURECUBEARRAY", "ITEXTURECUBEARRAY", "UTEXTURECUBEARRAY", - "TEXTURE2DMS", "ITEXTURE2DMS", "UTEXTURE2DMS", "TEXTURE2DMSARRAY", - "ITEXTURE2DMSARRAY", "UTEXTURE2DMSARRAY", "F16TEXTURE1D", "F16TEXTURE2D", - "F16TEXTURE3D", "F16TEXTURE2DRECT", "F16TEXTURECUBE", - "F16TEXTURE1DARRAY", "F16TEXTURE2DARRAY", "F16TEXTURECUBEARRAY", - "F16TEXTUREBUFFER", "F16TEXTURE2DMS", "F16TEXTURE2DMSARRAY", - "SUBPASSINPUT", "SUBPASSINPUTMS", "ISUBPASSINPUT", "ISUBPASSINPUTMS", - "USUBPASSINPUT", "USUBPASSINPUTMS", "F16SUBPASSINPUT", - "F16SUBPASSINPUTMS", "IMAGE1D", "IIMAGE1D", "UIMAGE1D", "IMAGE2D", - "IIMAGE2D", "UIMAGE2D", "IMAGE3D", "IIMAGE3D", "UIMAGE3D", "IMAGE2DRECT", - "IIMAGE2DRECT", "UIMAGE2DRECT", "IMAGECUBE", "IIMAGECUBE", "UIMAGECUBE", - "IMAGEBUFFER", "IIMAGEBUFFER", "UIMAGEBUFFER", "IMAGE1DARRAY", - "IIMAGE1DARRAY", "UIMAGE1DARRAY", "IMAGE2DARRAY", "IIMAGE2DARRAY", - "UIMAGE2DARRAY", "IMAGECUBEARRAY", "IIMAGECUBEARRAY", "UIMAGECUBEARRAY", - "IMAGE2DMS", "IIMAGE2DMS", "UIMAGE2DMS", "IMAGE2DMSARRAY", - "IIMAGE2DMSARRAY", "UIMAGE2DMSARRAY", "F16IMAGE1D", "F16IMAGE2D", - "F16IMAGE3D", "F16IMAGE2DRECT", "F16IMAGECUBE", "F16IMAGE1DARRAY", - "F16IMAGE2DARRAY", "F16IMAGECUBEARRAY", "F16IMAGEBUFFER", "F16IMAGE2DMS", + "FCOOPMATNV", "SAMPLER1D", "SAMPLER2D", "SAMPLER3D", "SAMPLERCUBE", + "SAMPLER1DSHADOW", "SAMPLER2DSHADOW", "SAMPLERCUBESHADOW", + "SAMPLER1DARRAY", "SAMPLER2DARRAY", "SAMPLER1DARRAYSHADOW", + "SAMPLER2DARRAYSHADOW", "ISAMPLER1D", "ISAMPLER2D", "ISAMPLER3D", + "ISAMPLERCUBE", "ISAMPLER1DARRAY", "ISAMPLER2DARRAY", "USAMPLER1D", + "USAMPLER2D", "USAMPLER3D", "USAMPLERCUBE", "USAMPLER1DARRAY", + "USAMPLER2DARRAY", "SAMPLER2DRECT", "SAMPLER2DRECTSHADOW", + "ISAMPLER2DRECT", "USAMPLER2DRECT", "SAMPLERBUFFER", "ISAMPLERBUFFER", + "USAMPLERBUFFER", "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", + "ISAMPLERCUBEARRAY", "USAMPLERCUBEARRAY", "SAMPLER2DMS", "ISAMPLER2DMS", + "USAMPLER2DMS", "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY", + "USAMPLER2DMSARRAY", "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT", + "F16SAMPLER1D", "F16SAMPLER2D", "F16SAMPLER3D", "F16SAMPLER2DRECT", + "F16SAMPLERCUBE", "F16SAMPLER1DARRAY", "F16SAMPLER2DARRAY", + "F16SAMPLERCUBEARRAY", "F16SAMPLERBUFFER", "F16SAMPLER2DMS", + "F16SAMPLER2DMSARRAY", "F16SAMPLER1DSHADOW", "F16SAMPLER2DSHADOW", + "F16SAMPLER1DARRAYSHADOW", "F16SAMPLER2DARRAYSHADOW", + "F16SAMPLER2DRECTSHADOW", "F16SAMPLERCUBESHADOW", + "F16SAMPLERCUBEARRAYSHADOW", "SAMPLER", "SAMPLERSHADOW", "TEXTURE1D", + "TEXTURE2D", "TEXTURE3D", "TEXTURECUBE", "TEXTURE1DARRAY", + "TEXTURE2DARRAY", "ITEXTURE1D", "ITEXTURE2D", "ITEXTURE3D", + "ITEXTURECUBE", "ITEXTURE1DARRAY", "ITEXTURE2DARRAY", "UTEXTURE1D", + "UTEXTURE2D", "UTEXTURE3D", "UTEXTURECUBE", "UTEXTURE1DARRAY", + "UTEXTURE2DARRAY", "TEXTURE2DRECT", "ITEXTURE2DRECT", "UTEXTURE2DRECT", + "TEXTUREBUFFER", "ITEXTUREBUFFER", "UTEXTUREBUFFER", "TEXTURECUBEARRAY", + "ITEXTURECUBEARRAY", "UTEXTURECUBEARRAY", "TEXTURE2DMS", "ITEXTURE2DMS", + "UTEXTURE2DMS", "TEXTURE2DMSARRAY", "ITEXTURE2DMSARRAY", + "UTEXTURE2DMSARRAY", "F16TEXTURE1D", "F16TEXTURE2D", "F16TEXTURE3D", + "F16TEXTURE2DRECT", "F16TEXTURECUBE", "F16TEXTURE1DARRAY", + "F16TEXTURE2DARRAY", "F16TEXTURECUBEARRAY", "F16TEXTUREBUFFER", + "F16TEXTURE2DMS", "F16TEXTURE2DMSARRAY", "SUBPASSINPUT", + "SUBPASSINPUTMS", "ISUBPASSINPUT", "ISUBPASSINPUTMS", "USUBPASSINPUT", + "USUBPASSINPUTMS", "F16SUBPASSINPUT", "F16SUBPASSINPUTMS", "IMAGE1D", + "IIMAGE1D", "UIMAGE1D", "IMAGE2D", "IIMAGE2D", "UIMAGE2D", "IMAGE3D", + "IIMAGE3D", "UIMAGE3D", "IMAGE2DRECT", "IIMAGE2DRECT", "UIMAGE2DRECT", + "IMAGECUBE", "IIMAGECUBE", "UIMAGECUBE", "IMAGEBUFFER", "IIMAGEBUFFER", + "UIMAGEBUFFER", "IMAGE1DARRAY", "IIMAGE1DARRAY", "UIMAGE1DARRAY", + "IMAGE2DARRAY", "IIMAGE2DARRAY", "UIMAGE2DARRAY", "IMAGECUBEARRAY", + "IIMAGECUBEARRAY", "UIMAGECUBEARRAY", "IMAGE2DMS", "IIMAGE2DMS", + "UIMAGE2DMS", "IMAGE2DMSARRAY", "IIMAGE2DMSARRAY", "UIMAGE2DMSARRAY", + "F16IMAGE1D", "F16IMAGE2D", "F16IMAGE3D", "F16IMAGE2DRECT", + "F16IMAGECUBE", "F16IMAGE1DARRAY", "F16IMAGE2DARRAY", + "F16IMAGECUBEARRAY", "F16IMAGEBUFFER", "F16IMAGE2DMS", "F16IMAGE2DMSARRAY", "STRUCT", "VOID", "WHILE", "IDENTIFIER", "TYPE_NAME", "FLOATCONSTANT", "DOUBLECONSTANT", "INT16CONSTANT", "UINT16CONSTANT", "INT32CONSTANT", "UINT32CONSTANT", "INTCONSTANT", @@ -1111,9 +1114,10 @@ static const char *const yytname[] = "layout_qualifier", "layout_qualifier_id_list", "layout_qualifier_id", "precise_qualifier", "type_qualifier", "single_type_qualifier", "storage_qualifier", "non_uniform_qualifier", "type_name_list", - "type_specifier", "array_specifier", "type_specifier_nonarray", - "precision_qualifier", "struct_specifier", "$@3", "$@4", - "struct_declaration_list", "struct_declaration", + "type_specifier", "array_specifier", "type_parameter_specifier_opt", + "type_parameter_specifier", "type_parameter_specifier_list", + "type_specifier_nonarray", "precision_qualifier", "struct_specifier", + "$@3", "$@4", "struct_declaration_list", "struct_declaration", "struct_declarator_list", "struct_declarator", "initializer", "initializer_list", "declaration_statement", "statement", "simple_statement", "compound_statement", "$@5", "$@6", @@ -1176,16 +1180,16 @@ static const yytype_uint16 yytoknum[] = 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, - 655, 656, 657, 658, 659, 660, 661 + 655, 656, 657, 658, 659, 660, 661, 662 }; # endif -#define YYPACT_NINF -657 +#define YYPACT_NINF -659 #define yypact_value_is_default(Yystate) \ - (!!((Yystate) == (-657))) + (!!((Yystate) == (-659))) -#define YYTABLE_NINF -518 +#define YYTABLE_NINF -524 #define yytable_value_is_error(Yytable_value) \ 0 @@ -1194,78 +1198,79 @@ static const yytype_uint16 yytoknum[] = STATE-NUM. */ static const yytype_int16 yypact[] = { - 3519, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -338, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -331, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -657, -318, -657, -657, -657, -657, -657, -657, - -657, -657, -258, -657, -319, -344, -303, -257, 5920, -281, - -657, -286, -657, -657, -657, -657, 4320, -657, -657, -657, - -657, -227, -657, -657, 712, -657, -657, -224, -68, -246, - -657, 8977, -339, -657, -657, -220, -657, 5920, -657, -657, - -657, 5920, -201, -175, -657, -341, -315, -657, -657, -657, - 6673, -206, -657, -657, -657, -308, -657, -214, -307, -657, - -657, 5920, -213, -657, -337, 1113, -657, -657, -657, -657, - -227, -322, -657, 7057, -321, -657, -167, -657, -261, -657, - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, 8209, 8209, 8209, -657, -657, -657, -657, -657, - -657, -657, -328, -657, -657, -657, -202, -285, 8593, -200, - -657, 8209, -244, -238, -266, -334, -207, -219, -217, -218, - -186, -183, -340, -196, -657, -657, 7441, -657, -157, 8209, - -657, -68, 5920, 5920, -156, 4720, -657, -657, -657, -199, - -195, -657, -190, -184, -192, 7825, -181, 8209, -194, -180, - -179, -178, -657, -657, -288, -657, -657, -259, -657, -344, - -174, -172, -657, -657, -657, -657, 1514, -657, -657, -657, - -657, -657, -657, -657, -657, -657, -19, -206, 7057, -312, - 7057, -657, -657, 7057, 5920, -657, -144, -657, -657, -657, - -284, -657, -657, 8209, -143, -657, -657, 8209, -171, -657, - -657, -657, 8209, 8209, 8209, 8209, 8209, 8209, 8209, 8209, - 8209, 8209, 8209, 8209, 8209, 8209, 8209, 8209, 8209, 8209, - 8209, -657, -657, -657, -169, -657, -657, -657, -657, 5120, - -156, -227, -255, -657, -657, -657, -657, -657, 1915, -657, - 8209, -657, -657, -253, 8209, -225, -657, -657, -136, -657, - 1915, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, 8209, 8209, -657, -657, -657, -657, -657, -657, - -657, 7057, -657, -240, -657, 5520, -657, -657, -168, -166, - -657, -657, -657, -657, -657, -244, -244, -238, -238, -266, - -266, -266, -266, -334, -334, -207, -219, -217, -218, -186, - -183, 8209, -657, -657, -247, -206, -156, -657, -132, 3118, - -282, -657, -277, -657, 3920, -164, -276, -657, 1915, -657, - -657, -657, -657, 6289, -657, -657, -221, -657, -657, -162, - -657, -657, 3920, -165, -657, -166, -125, 5920, -159, 8209, - -160, -136, -161, -657, -657, 8209, 8209, -657, -163, -155, - 194, -153, 2717, -657, -152, -134, 2316, -128, -657, -657, - -657, -657, -273, 8209, 2316, -165, -657, -657, 1915, 7057, - -657, -657, -657, -657, -133, -166, -657, -657, 1915, -129, - -657, -657, -657 + 3535, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -331, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -324, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -319, -659, -659, -659, -659, -659, + -659, -659, -659, -256, -659, -314, -351, -309, -306, 5942, + -257, -659, -217, -659, -659, -659, -659, 4338, -659, -659, + -659, -659, -241, -659, -659, 721, -659, -659, -204, -71, + -219, -659, 9007, -349, -659, -659, -215, -659, 5942, -659, + -659, -659, 5942, -178, -172, -659, -337, -267, -659, -659, + -659, 8237, -207, -659, -659, -659, -659, -341, -659, -211, + -330, -659, -659, 5942, -210, 6697, -659, -322, 1123, -659, + -659, -659, -659, -207, -328, -659, 7082, -304, -659, -163, + -659, -252, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -659, -659, -659, 8237, 8237, 8237, -659, -659, + -659, -659, -659, -659, -303, -659, -659, -659, -196, -299, + 8622, -194, -659, 8237, -659, -659, -355, -195, -659, -157, + 8237, -659, -71, 5942, 5942, -155, 4739, -659, -659, -659, + -659, -242, -236, -249, -335, -206, -191, -187, -209, -149, + -150, -333, -162, 7467, -659, -170, -168, -659, -154, -153, + -167, 7852, -152, 8237, -159, -148, -151, -160, -659, -659, + -274, -659, -659, -251, -659, -351, -147, -144, -659, -659, + -659, -659, 1525, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -19, -195, 7082, -302, 7082, -659, -659, 7082, + 5942, -659, -115, -659, -659, -659, -292, -659, -659, 8237, + -108, -659, -659, 8237, -143, -659, -659, -659, 8237, -659, + -659, -659, -659, -659, 5140, -155, -207, -250, -659, -659, + -659, 8237, 8237, 8237, 8237, 8237, 8237, 8237, 8237, 8237, + 8237, 8237, 8237, 8237, 8237, 8237, 8237, 8237, 8237, 8237, + -659, -659, -659, -142, -659, -659, 1927, -659, 8237, -659, + -659, -245, 8237, -226, -659, -659, -106, -659, 1927, -659, + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + 8237, 8237, -659, -659, -659, -659, -659, -659, -659, 7082, + -659, -238, -659, 5541, -659, -659, -141, -140, -659, -659, + -659, -659, -244, -195, -155, -659, -659, -659, -659, -242, + -242, -236, -236, -249, -249, -249, -249, -335, -335, -206, + -191, -187, -209, -149, -150, 8237, -659, -104, 3133, -263, + -659, -260, -659, 3937, -136, -297, -659, 1927, -659, -659, + -659, -659, 6312, -659, -659, -659, -659, -224, -135, -659, + -659, 3937, -138, -659, -140, -97, 5942, -132, 8237, -133, + -106, -134, -659, -659, 8237, 8237, -659, -137, -129, 224, + -128, 2731, -659, -127, -131, 2329, -126, -659, -659, -659, + -659, -255, 8237, 2329, -138, -659, -659, 1927, 7082, -659, + -659, -659, -659, -130, -140, -659, -659, 1927, -123, -659, + -659, -659 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -1273,110 +1278,111 @@ static const yytype_int16 yypact[] = means the default is an error. */ static const yytype_uint16 yydefact[] = { - 0, 157, 158, 197, 195, 198, 196, 199, 156, 210, - 200, 201, 208, 209, 206, 207, 204, 205, 202, 203, - 183, 226, 227, 228, 229, 230, 231, 244, 245, 246, - 241, 242, 243, 256, 257, 258, 238, 239, 240, 253, - 254, 255, 235, 236, 237, 250, 251, 252, 232, 233, - 234, 247, 248, 249, 211, 212, 213, 259, 260, 261, + 0, 157, 158, 202, 200, 203, 201, 204, 156, 215, + 205, 206, 213, 214, 211, 212, 209, 210, 207, 208, + 183, 231, 232, 233, 234, 235, 236, 249, 250, 251, + 246, 247, 248, 261, 262, 263, 243, 244, 245, 258, + 259, 260, 240, 241, 242, 255, 256, 257, 237, 238, + 239, 252, 253, 254, 216, 217, 218, 264, 265, 266, 162, 160, 161, 159, 165, 163, 164, 166, 172, 185, 168, 169, 167, 170, 171, 173, 179, 180, 181, 182, - 174, 175, 176, 177, 178, 214, 215, 216, 271, 272, - 273, 217, 218, 219, 283, 284, 285, 220, 221, 222, - 295, 296, 297, 223, 224, 225, 307, 308, 309, 134, - 133, 132, 0, 135, 136, 137, 138, 139, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 320, 319, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 347, 348, 349, 350, - 351, 352, 354, 355, 356, 357, 358, 359, 361, 362, - 365, 366, 367, 369, 370, 332, 333, 353, 360, 371, - 373, 374, 375, 377, 378, 469, 470, 334, 335, 336, - 363, 337, 341, 342, 345, 368, 372, 376, 338, 339, - 343, 344, 364, 340, 346, 379, 380, 381, 383, 385, - 387, 389, 391, 395, 396, 397, 398, 399, 400, 402, - 403, 404, 405, 406, 407, 409, 411, 412, 413, 415, - 416, 393, 401, 408, 417, 419, 420, 421, 423, 424, - 382, 384, 386, 410, 388, 390, 392, 394, 414, 418, - 422, 471, 472, 475, 476, 477, 478, 473, 474, 425, - 427, 428, 429, 431, 432, 433, 435, 436, 437, 439, - 440, 441, 443, 444, 445, 447, 448, 449, 451, 452, - 453, 455, 456, 457, 459, 460, 461, 463, 464, 465, - 467, 468, 426, 430, 434, 438, 442, 450, 454, 458, - 446, 462, 466, 0, 194, 480, 565, 131, 146, 481, - 482, 483, 0, 564, 0, 566, 0, 108, 107, 0, - 119, 124, 153, 152, 150, 154, 0, 147, 149, 155, - 129, 188, 151, 479, 0, 561, 563, 0, 0, 0, - 486, 0, 0, 96, 93, 0, 106, 0, 115, 109, - 117, 0, 118, 0, 94, 125, 0, 99, 148, 130, - 0, 189, 1, 562, 186, 0, 145, 143, 0, 141, - 484, 0, 0, 97, 0, 0, 567, 110, 114, 116, - 112, 120, 111, 0, 126, 102, 0, 100, 0, 2, - 12, 13, 10, 11, 4, 5, 6, 7, 8, 9, - 15, 14, 0, 0, 0, 190, 42, 41, 43, 40, - 3, 17, 36, 19, 24, 25, 0, 0, 29, 0, - 44, 0, 48, 51, 54, 59, 62, 64, 66, 68, - 70, 72, 74, 0, 35, 33, 0, 184, 0, 0, - 140, 0, 0, 0, 0, 0, 488, 95, 98, 0, - 0, 546, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 512, 521, 525, 44, 77, 90, 0, 501, 0, - 155, 129, 504, 523, 503, 502, 0, 505, 506, 527, - 507, 534, 508, 509, 542, 510, 0, 113, 0, 121, - 0, 496, 128, 0, 0, 104, 0, 101, 37, 38, - 0, 21, 22, 0, 0, 27, 26, 0, 194, 30, - 32, 39, 0, 0, 0, 0, 0, 0, 0, 0, + 174, 175, 176, 177, 178, 219, 220, 221, 276, 277, + 278, 222, 223, 224, 288, 289, 290, 225, 226, 227, + 300, 301, 302, 228, 229, 230, 312, 313, 314, 134, + 133, 132, 0, 135, 136, 137, 138, 139, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 325, 324, 484, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 335, 336, 352, 353, 354, + 355, 356, 357, 359, 360, 361, 362, 363, 364, 366, + 367, 370, 371, 372, 374, 375, 337, 338, 358, 365, + 376, 378, 379, 380, 382, 383, 474, 475, 339, 340, + 341, 368, 342, 346, 347, 350, 373, 377, 381, 343, + 344, 348, 349, 369, 345, 351, 384, 385, 386, 388, + 390, 392, 394, 396, 400, 401, 402, 403, 404, 405, + 407, 408, 409, 410, 411, 412, 414, 416, 417, 418, + 420, 421, 398, 406, 413, 422, 424, 425, 426, 428, + 429, 387, 389, 391, 415, 393, 395, 397, 399, 419, + 423, 427, 476, 477, 480, 481, 482, 483, 478, 479, + 430, 432, 433, 434, 436, 437, 438, 440, 441, 442, + 444, 445, 446, 448, 449, 450, 452, 453, 454, 456, + 457, 458, 460, 461, 462, 464, 465, 466, 468, 469, + 470, 472, 473, 431, 435, 439, 443, 447, 455, 459, + 463, 451, 467, 471, 0, 199, 486, 571, 131, 146, + 487, 488, 489, 0, 570, 0, 572, 0, 108, 107, + 0, 119, 124, 153, 152, 150, 154, 0, 147, 149, + 155, 129, 195, 151, 485, 0, 567, 569, 0, 0, + 0, 492, 0, 0, 96, 93, 0, 106, 0, 115, + 109, 117, 0, 118, 0, 94, 125, 0, 99, 148, + 130, 0, 188, 194, 1, 568, 186, 0, 145, 143, + 0, 141, 490, 0, 0, 0, 97, 0, 0, 573, + 110, 114, 116, 112, 120, 111, 0, 126, 102, 0, + 100, 0, 2, 12, 13, 10, 11, 4, 5, 6, + 7, 8, 9, 15, 14, 0, 0, 0, 42, 41, + 43, 40, 3, 17, 36, 19, 24, 25, 0, 0, + 29, 0, 197, 0, 35, 33, 0, 189, 184, 0, + 0, 140, 0, 0, 0, 0, 0, 494, 95, 190, + 44, 48, 51, 54, 59, 62, 64, 66, 68, 70, + 72, 74, 0, 0, 98, 0, 0, 552, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 518, 527, 531, + 44, 77, 90, 0, 507, 0, 155, 129, 510, 529, + 509, 508, 0, 511, 512, 533, 513, 540, 514, 515, + 548, 516, 0, 113, 0, 121, 0, 502, 128, 0, + 0, 104, 0, 101, 37, 38, 0, 21, 22, 0, + 0, 27, 26, 0, 199, 30, 32, 39, 0, 196, + 187, 92, 144, 142, 0, 0, 500, 0, 498, 493, + 495, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 75, 191, 192, 0, 187, 92, 144, 142, 0, - 0, 494, 0, 492, 487, 489, 557, 556, 0, 548, - 0, 560, 558, 0, 0, 0, 541, 544, 0, 511, - 0, 80, 81, 83, 82, 85, 86, 87, 88, 89, - 84, 79, 0, 0, 526, 522, 524, 528, 535, 543, - 123, 0, 499, 0, 127, 0, 105, 16, 0, 23, - 20, 31, 45, 46, 47, 50, 49, 52, 53, 57, - 58, 55, 56, 60, 61, 63, 65, 67, 69, 71, - 73, 0, 193, 485, 0, 495, 0, 490, 0, 0, - 0, 559, 0, 540, 0, 571, 0, 569, 513, 78, - 91, 122, 497, 0, 103, 18, 0, 491, 493, 0, - 551, 550, 553, 519, 536, 532, 0, 0, 0, 0, - 0, 0, 0, 498, 500, 0, 0, 552, 0, 0, - 531, 0, 0, 529, 0, 0, 0, 0, 568, 570, - 514, 76, 0, 554, 0, 519, 518, 520, 538, 0, - 516, 545, 515, 572, 0, 555, 549, 530, 539, 0, - 533, 547, 537 + 75, 191, 192, 0, 563, 562, 0, 554, 0, 566, + 564, 0, 0, 0, 547, 550, 0, 517, 0, 80, + 81, 83, 82, 85, 86, 87, 88, 89, 84, 79, + 0, 0, 532, 528, 530, 534, 541, 549, 123, 0, + 505, 0, 127, 0, 105, 16, 0, 23, 20, 31, + 198, 491, 0, 501, 0, 496, 45, 46, 47, 50, + 49, 52, 53, 57, 58, 55, 56, 60, 61, 63, + 65, 67, 69, 71, 73, 0, 193, 0, 0, 0, + 565, 0, 546, 0, 577, 0, 575, 519, 78, 91, + 122, 503, 0, 103, 18, 497, 499, 0, 0, 557, + 556, 559, 525, 542, 538, 0, 0, 0, 0, 0, + 0, 0, 504, 506, 0, 0, 558, 0, 0, 537, + 0, 0, 535, 0, 0, 0, 0, 574, 576, 520, + 76, 0, 560, 0, 525, 524, 526, 544, 0, 522, + 551, 521, 578, 0, 561, 555, 536, 545, 0, 539, + 553, 543 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -657, -657, -657, -657, -657, -657, -657, -657, -657, -657, - -657, -657, -305, -657, -373, -372, -429, -376, -323, -294, - -324, -295, -293, -296, -657, -370, -657, -394, -657, -383, - -414, 1, -657, -657, -657, 2, -657, -657, -657, -114, - -109, -111, -657, -657, -613, -657, -657, -657, -657, -198, - -657, -335, -342, -657, 6, -657, 0, -350, -657, -70, - -657, -657, -657, -444, -450, -292, -371, -494, -657, -375, - -462, -656, -415, -657, -657, -427, -426, -657, -657, -93, - -563, -366, -657, -232, -657, -387, -657, -230, -657, -657, - -657, -657, -229, -657, -657, -657, -657, -657, -657, -657, - -657, -76, -657, -657, -657, -657, -391 + -659, -659, -659, -659, -659, -659, -659, -659, -659, -659, + -659, -659, -364, -659, -389, -385, -457, -384, -310, -307, + -305, -308, -301, -298, -659, -386, -659, -390, -659, -415, + -418, 1, -659, -659, -659, 2, -659, -659, -659, -110, + -105, -107, -659, -659, -628, -659, -659, -659, -659, -188, + -659, -336, -343, -659, 6, -659, 0, -334, -659, -659, + -659, -659, -67, -659, -659, -659, -431, -437, -277, -350, + -501, -659, -375, -488, -658, -414, -659, -659, -428, -426, + -659, -659, -87, -568, -368, -659, -231, -659, -388, -659, + -230, -659, -659, -659, -659, -228, -659, -659, -659, -659, + -659, -659, -659, -659, -70, -659, -659, -659, -659, -394 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 430, 431, 432, 608, 433, 434, 435, 436, 437, - 438, 439, 484, 441, 442, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 485, 631, 486, 592, 487, - 557, 488, 334, 514, 408, 489, 336, 337, 338, 368, - 369, 370, 339, 340, 341, 342, 343, 344, 388, 389, - 345, 346, 347, 348, 454, 385, 455, 381, 351, 352, - 353, 462, 391, 465, 466, 562, 563, 512, 603, 492, - 493, 494, 495, 580, 672, 701, 680, 681, 682, 702, - 496, 497, 498, 499, 683, 668, 500, 501, 684, 709, - 502, 503, 504, 644, 568, 639, 662, 678, 679, 505, - 354, 355, 356, 365, 506, 646, 647 + -1, 432, 433, 434, 616, 435, 436, 437, 438, 439, + 440, 441, 490, 443, 461, 462, 463, 464, 465, 466, + 467, 468, 469, 470, 471, 491, 645, 492, 600, 493, + 542, 494, 335, 520, 411, 495, 337, 338, 339, 369, + 370, 371, 340, 341, 342, 343, 344, 345, 390, 391, + 346, 347, 348, 349, 444, 387, 445, 397, 382, 383, + 446, 352, 353, 354, 453, 393, 456, 457, 547, 548, + 518, 611, 498, 499, 500, 501, 588, 681, 710, 689, + 690, 691, 711, 502, 503, 504, 505, 692, 677, 506, + 507, 693, 718, 508, 509, 510, 653, 576, 648, 671, + 687, 688, 511, 355, 356, 357, 366, 512, 655, 656 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -1384,121 +1390,122 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 350, 333, 335, 371, 378, 471, 349, 472, 473, 511, - 453, 476, 394, 386, 600, 565, 602, 648, 559, 604, - 362, 359, 550, 539, 540, 404, 697, 521, 522, 378, - 700, 666, 371, 402, 596, 380, 357, 380, 700, 456, - 364, 520, 403, 358, 529, 393, -34, 468, 523, 666, - 507, 509, 524, 375, 380, 456, 463, 551, 541, 542, - 360, 508, 513, 405, 456, 363, 406, 457, 460, 407, - 605, 601, 366, 458, 461, 440, 581, 582, 583, 584, - 585, 586, 587, 588, 589, 590, 554, 537, 538, 556, - 526, 607, 573, 663, 575, 591, 527, 593, 664, 593, - 373, 670, 704, 374, 593, 671, 638, 651, 593, 565, - 619, 620, 621, 622, 511, 384, 511, 518, 519, 511, - 516, 378, 593, 517, 367, 594, 636, 463, 593, 637, - 463, 641, 390, 611, 636, 708, 531, 657, 400, 652, - 609, 653, 329, 330, 331, 532, 533, 534, 535, 380, - 536, 440, 543, 544, 440, 565, 593, 643, 395, 674, - 593, 675, 615, 616, 401, 617, 618, 623, 624, 459, - 456, 467, 515, 525, 530, 548, 547, 545, 546, 463, - 549, 552, 555, 561, 569, 566, 596, 640, 576, 567, - 570, 642, 571, 574, 577, 606, 610, 578, 649, 650, - -35, 579, -33, 645, -28, 710, 659, 511, 632, 655, - 669, 635, 676, -517, 685, 593, 686, 688, 690, 695, - 694, 693, 625, 627, 463, 481, 698, 612, 613, 614, - 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, - 440, 440, 440, 440, 440, 440, 596, 703, 656, 699, - 712, 711, 626, 628, 630, 687, 629, 398, 397, 511, - 399, 665, 361, 558, 660, 658, 696, 706, 634, 707, - 463, 387, 396, 661, 597, 677, 598, 599, 383, 665, - 689, 691, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 692, 0, 0, 0, 0, 0, 556, - 0, 0, 0, 0, 0, 511, 0, 0, 0, 667, - 705, 0, 0, 0, 0, 0, 0, 0, 0, 479, - 0, 0, 0, 0, 0, 378, 0, 667, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 372, 0, - 0, 0, 0, 0, 349, 0, 379, 0, 0, 0, - 0, 0, 349, 0, 350, 333, 335, 0, 0, 0, - 349, 392, 0, 0, 440, 0, 0, 372, 0, 0, - 0, 372, 0, 349, 0, 0, 0, 349, 0, 0, + 351, 334, 336, 372, 379, 477, 350, 478, 479, 472, + 388, 482, 526, 608, 604, 610, 517, 442, 612, 550, + 657, 360, 544, 558, 559, 675, 363, 538, 395, 379, + 569, 460, 372, 706, 365, 448, 396, 709, 405, 539, + 395, 449, 407, 675, 358, 709, 451, 406, 447, 395, + 535, 359, 452, 527, 528, 473, 514, 454, 560, 561, + 361, 524, 525, 474, 541, 570, 581, 367, 583, 513, + 515, 364, -34, 473, 529, 473, 368, 532, 530, 537, + 519, 679, 609, 533, 615, 680, 460, 573, 647, 613, + 601, 589, 590, 591, 592, 593, 594, 595, 596, 597, + 598, 633, 634, 635, 636, 556, 557, 550, 660, 460, + 599, 379, 408, 672, 617, 409, 673, 454, 410, 601, + 454, 713, 601, 376, 517, 374, 517, 601, 375, 517, + 522, 601, 624, 523, 602, 625, 386, 601, 624, 717, + 650, 665, 661, 619, 662, 330, 331, 332, 551, 552, + 553, 554, 381, 555, 562, 563, 601, 652, 601, 684, + 392, 683, 403, 649, 398, 629, 630, 651, 404, 604, + 395, 631, 632, 450, 620, 458, 550, 521, 637, 638, + 531, 536, 473, 540, 454, 546, 566, 626, 627, 628, + 460, 460, 460, 460, 460, 460, 460, 460, 460, 460, + 460, 460, 460, 460, 460, 460, 564, 719, 454, 565, + 658, 659, 623, 567, 568, 574, 571, 575, 579, 517, + 587, 577, 578, 582, 584, 614, 586, 585, -35, 604, + 667, -33, 618, -28, 654, 668, 646, 664, 674, 678, + 685, -523, 601, 694, 695, 697, 699, 703, 702, 704, + 712, 487, 707, 708, 639, 720, 674, 721, 640, 642, + 696, 641, 401, 400, 543, 402, 362, 643, 622, 389, + 701, 644, 517, 669, 666, 715, 705, 454, 716, 399, + 670, 605, 606, 686, 607, 385, 698, 714, 0, 0, + 0, 0, 541, 0, 700, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 464, 0, 0, 0, 491, 0, 349, 0, 0, - 0, 490, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 460, 0, 0, 676, 517, 0, + 485, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 379, 0, 676, 0, 0, 0, 373, + 0, 0, 0, 0, 0, 350, 0, 380, 0, 0, + 0, 0, 0, 350, 0, 351, 334, 336, 0, 0, + 0, 350, 394, 0, 0, 0, 0, 0, 373, 0, + 0, 0, 373, 0, 350, 0, 0, 0, 350, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 455, 0, 0, 0, 0, 497, 350, + 0, 0, 0, 0, 496, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 464, 560, 0, 464, 0, 0, 349, 349, - 0, 349, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 491, 0, 0, 0, - 0, 0, 490, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 464, 0, 0, 0, 0, 0, - 349, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 464, - 0, 0, 0, 0, 0, 349, 0, 0, 491, 0, - 0, 0, 0, 0, 490, 0, 0, 0, 0, 0, - 491, 0, 0, 0, 0, 0, 490, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 464, 0, 0, 0, 0, - 0, 349, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 491, - 0, 0, 0, 0, 491, 490, 0, 0, 491, 0, - 490, 0, 0, 0, 490, 0, 0, 0, 0, 0, - 0, 0, 491, 0, 0, 0, 0, 379, 490, 0, - 0, 0, 0, 349, 0, 0, 0, 0, 0, 0, - 0, 0, 491, 0, 0, 0, 491, 0, 490, 0, - 0, 0, 490, 0, 491, 0, 0, 0, 491, 0, - 490, 0, 0, 0, 490, 0, 0, 0, 491, 0, - 0, 0, 382, 0, 490, 1, 2, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 0, 0, 325, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 455, 545, 0, 455, 0, 0, 350, + 350, 0, 350, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, + 0, 0, 497, 0, 0, 0, 0, 0, 496, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 327, 328, 329, 330, 331, 332, 1, 2, 3, 4, + 455, 0, 0, 0, 0, 0, 350, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 455, 0, 0, 0, 0, 0, + 350, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 497, 0, 0, 0, + 0, 0, 496, 0, 0, 0, 0, 0, 497, 0, + 0, 0, 0, 0, 496, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 455, 0, 0, 0, 0, 0, 350, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 497, 0, + 0, 0, 0, 497, 496, 0, 0, 497, 0, 496, + 0, 0, 0, 496, 0, 0, 0, 0, 0, 0, + 0, 497, 0, 0, 0, 0, 380, 496, 0, 0, + 0, 0, 350, 0, 0, 0, 0, 0, 0, 0, + 0, 497, 0, 0, 0, 497, 0, 496, 0, 0, + 0, 496, 0, 497, 0, 0, 0, 497, 0, 496, + 0, 0, 0, 496, 0, 0, 0, 497, 0, 0, + 0, 384, 0, 496, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 327, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 328, 329, 330, 331, 332, 333, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 469, 470, 471, 0, 472, - 473, 474, 475, 476, 477, 478, 20, 21, 22, 23, + 15, 16, 17, 18, 19, 475, 476, 477, 0, 478, + 479, 480, 481, 482, 483, 484, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, @@ -1529,56 +1536,16 @@ static const yytype_int16 yytable[] = 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 479, 409, 325, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 421, 0, 0, 422, 423, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 424, 0, 480, - 0, 481, 482, 0, 0, 0, 0, 483, 426, 427, - 428, 429, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 327, 328, 329, 330, 331, 332, 1, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 469, 470, 471, 0, - 472, 473, 474, 475, 476, 477, 478, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 479, 409, 325, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 421, 0, 0, 422, - 423, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 424, 0, - 480, 0, 481, 595, 0, 0, 0, 0, 483, 426, - 427, 428, 429, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 327, 328, 329, 330, 331, 332, 1, 2, + 324, 325, 485, 412, 326, 413, 414, 415, 416, 417, + 418, 419, 420, 421, 422, 423, 424, 0, 0, 425, + 426, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 427, 0, + 486, 0, 487, 488, 0, 0, 0, 0, 489, 428, + 429, 430, 431, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 328, 329, 330, 331, 332, 333, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 469, 470, 471, - 0, 472, 473, 474, 475, 476, 477, 478, 20, 21, + 13, 14, 15, 16, 17, 18, 19, 475, 476, 477, + 0, 478, 479, 480, 481, 482, 483, 484, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, @@ -1609,56 +1576,16 @@ static const yytype_int16 yytable[] = 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 323, 324, 479, 409, 325, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 421, 0, 0, - 422, 423, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 424, - 0, 480, 0, 481, 0, 0, 0, 0, 0, 483, - 426, 427, 428, 429, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 327, 328, 329, 330, 331, 332, 1, - 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 469, 470, - 471, 0, 472, 473, 474, 475, 476, 477, 478, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 479, 409, 325, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 421, 0, - 0, 422, 423, 0, 0, 0, 0, 0, 0, 0, + 322, 323, 324, 325, 485, 412, 326, 413, 414, 415, + 416, 417, 418, 419, 420, 421, 422, 423, 424, 0, + 0, 425, 426, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 424, 0, 480, 0, 395, 0, 0, 0, 0, 0, - 483, 426, 427, 428, 429, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 327, 328, 329, 330, 331, 332, + 427, 0, 486, 0, 487, 603, 0, 0, 0, 0, + 489, 428, 429, 430, 431, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 328, 329, 330, 331, 332, 333, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 469, - 470, 471, 0, 472, 473, 474, 475, 476, 477, 478, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, @@ -1689,13 +1616,214 @@ static const yytype_int16 yytable[] = 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 479, 409, 325, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, - 0, 0, 422, 423, 0, 0, 0, 0, 0, 0, + 320, 321, 322, 323, 324, 325, 485, 412, 326, 413, + 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, + 424, 0, 0, 425, 426, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 424, 0, 480, 0, 0, 0, 0, 0, 0, - 0, 483, 426, 427, 428, 429, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 327, 328, 329, 330, 331, + 0, 0, 427, 0, 486, 0, 487, 0, 0, 0, + 0, 0, 489, 428, 429, 430, 431, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 328, 329, 330, 331, + 332, 333, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 475, 476, 477, 0, 478, 479, 480, 481, 482, + 483, 484, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 485, 412, + 326, 413, 414, 415, 416, 417, 418, 419, 420, 421, + 422, 423, 424, 0, 0, 425, 426, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 427, 0, 486, 0, 398, 0, + 0, 0, 0, 0, 489, 428, 429, 430, 431, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 328, 329, + 330, 331, 332, 333, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 475, 476, 477, 0, 478, 479, 480, + 481, 482, 483, 484, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 485, 412, 326, 413, 414, 415, 416, 417, 418, 419, + 420, 421, 422, 423, 424, 0, 0, 425, 426, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 427, 0, 486, 0, + 0, 0, 0, 0, 0, 0, 489, 428, 429, 430, + 431, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 328, 329, 330, 331, 332, 333, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 0, 412, 326, 413, 414, 415, 416, 417, + 418, 419, 420, 421, 422, 423, 424, 0, 0, 425, + 426, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 427, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 489, 428, + 429, 430, 431, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 328, 329, 330, 331, 332, 333, 1, 2, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 0, 0, 326, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 327, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 328, 329, 330, 331, 332, 333, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 0, 412, 326, 413, + 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, + 424, 0, 0, 425, 426, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 427, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 428, 429, 430, 431, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 328, 329, 330, 331, 332, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -1729,13 +1857,13 @@ static const yytype_int16 yytable[] = 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 0, 409, 325, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 421, 0, 0, 422, 423, 0, 0, 0, 0, 0, + 319, 320, 321, 322, 323, 324, 325, 0, 377, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 424, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 483, 426, 427, 428, 429, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 327, 328, 329, 330, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 378, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 328, 329, 330, 331, 332, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -1769,13 +1897,13 @@ static const yytype_int16 yytable[] = 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 0, 0, 325, + 318, 319, 320, 321, 322, 323, 324, 325, 0, 0, + 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 549, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 327, 328, 329, + 0, 0, 0, 0, 0, 0, 0, 0, 328, 329, 330, 331, 332, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, @@ -1809,288 +1937,130 @@ static const yytype_int16 yytable[] = 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 0, 409, - 325, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 421, 0, 0, 422, 423, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 424, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 426, 427, 428, 429, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 327, 328, - 329, 330, 331, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 0, 376, - 325, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 0, + 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 377, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 327, 328, - 329, 330, 331, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 0, 0, - 325, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 621, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 328, + 329, 330, 331, 332, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 564, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 327, 328, - 329, 330, 331, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 0, 0, - 325, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 663, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 328, 329, 330, 331, 332, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 633, + 0, 0, 0, 0, 0, 0, 0, 3, 4, 5, + 6, 7, 0, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, + 0, 328, 329, 330, 331, 332, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 327, 328, - 329, 330, 331, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 0, 0, - 325, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 0, 412, 326, 413, 414, 415, 416, 417, 418, + 419, 420, 421, 422, 423, 424, 0, 0, 425, 426, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 654, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 327, 328, - 329, 330, 331, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 0, 0, - 325, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3, 4, 5, 6, 7, 0, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 0, 0, 0, 0, 0, 0, 0, 327, 328, - 329, 330, 331, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 0, 409, 325, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 421, 0, 0, 422, 423, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 424, 0, 0, 0, 510, 673, 0, - 0, 0, 0, 0, 426, 427, 428, 429, 3, 4, - 5, 6, 7, 0, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 69, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 0, 409, 325, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 421, 0, 0, 422, 423, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 424, 0, 0, - 425, 0, 0, 0, 0, 0, 0, 0, 426, 427, - 428, 429, 3, 4, 5, 6, 7, 0, 9, 10, + 0, 0, 0, 0, 0, 0, 0, 427, 0, 0, + 0, 516, 682, 0, 0, 0, 0, 0, 428, 429, + 430, 431, 3, 4, 5, 6, 7, 0, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22, 23, 24, 25, 26, 27, 28, 29, @@ -2123,166 +2093,205 @@ static const yytype_int16 yytable[] = 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 0, 409, 325, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, - 0, 0, 422, 423, 0, 0, 0, 0, 0, 0, + 320, 321, 322, 323, 324, 325, 0, 412, 326, 413, + 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, + 424, 0, 0, 425, 426, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 424, 0, 0, 0, 510, 0, 0, 0, 0, - 0, 0, 426, 427, 428, 429, 3, 4, 5, 6, - 7, 0, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 0, - 409, 325, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, 0, 0, 422, 423, 0, 0, + 0, 0, 427, 0, 0, 459, 0, 0, 0, 0, + 0, 0, 0, 428, 429, 430, 431, 3, 4, 5, + 6, 7, 0, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 424, 0, 0, 553, 0, - 0, 0, 0, 0, 0, 0, 426, 427, 428, 429, - 3, 4, 5, 6, 7, 0, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 0, 412, 326, 413, 414, 415, 416, 417, 418, + 419, 420, 421, 422, 423, 424, 0, 0, 425, 426, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 323, 324, 0, 409, 325, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 421, 0, 0, - 422, 423, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 424, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 572, - 426, 427, 428, 429, 3, 4, 5, 6, 7, 0, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 0, 409, 325, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 421, 0, 0, 422, 423, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 427, 0, 0, + 0, 516, 0, 0, 0, 0, 0, 0, 428, 429, + 430, 431, 3, 4, 5, 6, 7, 0, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 424, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 426, 427, 428, 429, 3, 4, - 5, 6, 7, 0, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 69, 0, 0, 0, 0, + 0, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 528, 0, 409, 325, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 421, 0, 0, 422, 423, + 0, 0, 0, 0, 0, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 0, 412, 326, 413, + 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, + 424, 0, 0, 425, 426, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 424, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 426, 427, - 428, 429, 3, 4, 5, 6, 7, 0, 9, 10, + 0, 0, 427, 0, 0, 572, 0, 0, 0, 0, + 0, 0, 0, 428, 429, 430, 431, 3, 4, 5, + 6, 7, 0, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 69, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 0, 412, 326, 413, 414, 415, 416, 417, 418, + 419, 420, 421, 422, 423, 424, 0, 0, 425, 426, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 427, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 580, 428, 429, + 430, 431, 3, 4, 5, 6, 7, 0, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 69, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 0, 412, 326, 413, + 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, + 424, 0, 0, 425, 426, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 427, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 428, 429, 430, 431, 3, 4, 5, + 6, 7, 0, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 69, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 534, 0, 412, 326, 413, 414, 415, 416, 417, 418, + 419, 420, 421, 422, 423, 424, 0, 0, 425, 426, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 427, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 428, 429, + 430, 431, 3, 4, 5, 6, 7, 0, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22, 23, 24, 25, 26, 27, 28, 29, @@ -2315,123 +2324,124 @@ static const yytype_int16 yytable[] = 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 0, 0, 325 + 320, 321, 322, 323, 324, 325, 0, 0, 326 }; static const yytype_int16 yycheck[] = { - 0, 0, 0, 338, 346, 24, 0, 26, 27, 403, - 380, 30, 362, 81, 508, 465, 510, 580, 462, 513, - 339, 339, 362, 357, 358, 375, 682, 355, 356, 371, - 686, 644, 367, 374, 496, 376, 374, 376, 694, 376, - 384, 424, 383, 374, 438, 384, 374, 384, 376, 662, - 400, 401, 380, 339, 376, 376, 391, 397, 392, 393, - 378, 383, 383, 378, 376, 384, 381, 375, 375, 384, - 514, 383, 375, 381, 381, 380, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 456, 353, 354, 459, - 375, 375, 475, 375, 477, 383, 381, 381, 375, 381, - 381, 377, 375, 384, 381, 381, 568, 601, 381, 559, - 539, 540, 541, 542, 508, 339, 510, 422, 423, 513, - 381, 463, 381, 384, 381, 384, 381, 462, 381, 384, - 465, 384, 378, 527, 381, 698, 441, 384, 339, 379, - 523, 381, 400, 401, 402, 389, 390, 391, 386, 376, - 388, 456, 359, 360, 459, 605, 381, 382, 378, 653, - 381, 382, 535, 536, 339, 537, 538, 543, 544, 383, - 376, 384, 339, 375, 374, 361, 394, 396, 395, 514, - 363, 377, 339, 339, 374, 384, 648, 570, 382, 384, - 374, 574, 384, 374, 374, 339, 339, 376, 592, 593, - 374, 379, 374, 339, 375, 699, 338, 601, 377, 377, - 374, 561, 374, 378, 339, 381, 375, 377, 379, 25, - 375, 384, 545, 547, 559, 378, 378, 532, 533, 534, - 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, - 545, 546, 547, 548, 549, 550, 708, 375, 631, 383, - 379, 384, 546, 548, 550, 669, 549, 371, 367, 653, - 371, 644, 332, 461, 639, 636, 681, 694, 560, 695, - 605, 339, 365, 639, 506, 662, 506, 506, 354, 662, - 671, 675, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 676, -1, -1, -1, -1, -1, 669, - -1, -1, -1, -1, -1, 699, -1, -1, -1, 644, - 693, -1, -1, -1, -1, -1, -1, -1, -1, 338, - -1, -1, -1, -1, -1, 667, -1, 662, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 338, -1, - -1, -1, -1, -1, 338, -1, 346, -1, -1, -1, - -1, -1, 346, -1, 354, 354, 354, -1, -1, -1, - 354, 361, -1, -1, 669, -1, -1, 367, -1, -1, - -1, 371, -1, 367, -1, -1, -1, 371, -1, -1, + 0, 0, 0, 339, 347, 24, 0, 26, 27, 395, + 81, 30, 427, 514, 502, 516, 406, 381, 519, 456, + 588, 340, 453, 358, 359, 653, 340, 382, 377, 372, + 363, 395, 368, 691, 385, 376, 385, 695, 375, 394, + 377, 382, 376, 671, 375, 703, 376, 384, 382, 377, + 440, 375, 382, 356, 357, 377, 384, 393, 393, 394, + 379, 425, 426, 385, 450, 398, 481, 376, 483, 403, + 404, 385, 375, 377, 377, 377, 382, 376, 381, 443, + 384, 378, 384, 382, 376, 382, 450, 473, 576, 520, + 382, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 558, 559, 560, 561, 354, 355, 544, 609, 473, + 384, 454, 379, 376, 529, 382, 376, 453, 385, 382, + 456, 376, 382, 340, 514, 382, 516, 382, 385, 519, + 382, 382, 382, 385, 385, 385, 340, 382, 382, 707, + 385, 385, 380, 533, 382, 401, 402, 403, 390, 391, + 392, 387, 393, 389, 360, 361, 382, 383, 382, 383, + 379, 662, 340, 578, 379, 554, 555, 582, 340, 657, + 377, 556, 557, 384, 538, 385, 613, 340, 562, 563, + 376, 375, 377, 340, 520, 340, 395, 551, 552, 553, + 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, + 564, 565, 566, 567, 568, 569, 397, 708, 544, 396, + 600, 601, 546, 362, 364, 385, 378, 385, 385, 609, + 380, 375, 375, 375, 383, 340, 377, 375, 375, 717, + 645, 375, 340, 376, 340, 339, 378, 378, 653, 375, + 375, 379, 382, 340, 376, 378, 380, 376, 385, 25, + 376, 379, 379, 384, 564, 385, 671, 380, 565, 567, + 678, 566, 372, 368, 452, 372, 333, 568, 545, 340, + 685, 569, 662, 648, 624, 703, 690, 613, 704, 366, + 648, 512, 512, 671, 512, 355, 680, 702, -1, -1, + -1, -1, 678, -1, 684, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 391, -1, -1, -1, 395, -1, 391, -1, -1, - -1, 395, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 678, -1, -1, 653, 708, -1, + 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 676, -1, 671, -1, -1, -1, 339, + -1, -1, -1, -1, -1, 339, -1, 347, -1, -1, + -1, -1, -1, 347, -1, 355, 355, 355, -1, -1, + -1, 355, 362, -1, -1, -1, -1, -1, 368, -1, + -1, -1, 372, -1, 368, -1, -1, -1, 372, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 393, -1, -1, -1, -1, 398, 393, + -1, -1, -1, -1, 398, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 462, 463, -1, 465, -1, -1, 462, 463, - -1, 465, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 496, -1, -1, -1, - -1, -1, 496, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 514, -1, -1, -1, -1, -1, - 514, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 559, - -1, -1, -1, -1, -1, 559, -1, -1, 568, -1, - -1, -1, -1, -1, 568, -1, -1, -1, -1, -1, - 580, -1, -1, -1, -1, -1, 580, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 605, -1, -1, -1, -1, - -1, 605, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 639, - -1, -1, -1, -1, 644, 639, -1, -1, 648, -1, - 644, -1, -1, -1, 648, -1, -1, -1, -1, -1, - -1, -1, 662, -1, -1, -1, -1, 667, 662, -1, - -1, -1, -1, 667, -1, -1, -1, -1, -1, -1, - -1, -1, 682, -1, -1, -1, 686, -1, 682, -1, - -1, -1, 686, -1, 694, -1, -1, -1, 698, -1, - 694, -1, -1, -1, 698, -1, -1, -1, 708, -1, - -1, -1, 0, -1, 708, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, - -1, -1, 340, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 453, 454, -1, 456, -1, -1, 453, + 454, -1, 456, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 384, -1, -1, -1, + -1, -1, 502, -1, -1, -1, -1, -1, 502, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 398, 399, 400, 401, 402, 403, 3, 4, 5, 6, + 520, -1, -1, -1, -1, -1, 520, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 544, -1, -1, -1, -1, -1, + 544, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 576, -1, -1, -1, + -1, -1, 576, -1, -1, -1, -1, -1, 588, -1, + -1, -1, -1, -1, 588, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 613, -1, -1, -1, -1, -1, 613, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 648, -1, + -1, -1, -1, 653, 648, -1, -1, 657, -1, 653, + -1, -1, -1, 657, -1, -1, -1, -1, -1, -1, + -1, 671, -1, -1, -1, -1, 676, 671, -1, -1, + -1, -1, 676, -1, -1, -1, -1, -1, -1, -1, + -1, 691, -1, -1, -1, 695, -1, 691, -1, -1, + -1, 695, -1, 703, -1, -1, -1, 707, -1, 703, + -1, -1, -1, 707, -1, -1, -1, 717, -1, -1, + -1, 0, -1, 717, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + -1, -1, 341, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 385, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 399, 400, 401, 402, 403, 404, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, @@ -2466,52 +2476,12 @@ static const yytype_int16 yycheck[] = 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 351, 352, -1, -1, 355, 356, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 374, -1, 376, - -1, 378, 379, -1, -1, -1, -1, 384, 385, 386, - 387, 388, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 398, 399, 400, 401, 402, 403, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, -1, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, - 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 351, 352, -1, -1, 355, - 356, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 374, -1, - 376, -1, 378, 379, -1, -1, -1, -1, 384, 385, - 386, 387, 388, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 398, 399, 400, 401, 402, 403, 3, 4, + 347, 348, 349, 350, 351, 352, 353, -1, -1, 356, + 357, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 375, -1, + 377, -1, 379, 380, -1, -1, -1, -1, 385, 386, + 387, 388, 389, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 399, 400, 401, 402, 403, 404, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, @@ -2546,52 +2516,12 @@ static const yytype_int16 yycheck[] = 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, 347, 348, 349, 350, 351, 352, -1, -1, - 355, 356, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 374, - -1, 376, -1, 378, -1, -1, -1, -1, -1, 384, - 385, 386, 387, 388, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 398, 399, 400, 401, 402, 403, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, -1, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, - -1, 355, 356, -1, -1, -1, -1, -1, -1, -1, + 345, 346, 347, 348, 349, 350, 351, 352, 353, -1, + -1, 356, 357, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 374, -1, 376, -1, 378, -1, -1, -1, -1, -1, - 384, 385, 386, 387, 388, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 398, 399, 400, 401, 402, 403, + 375, -1, 377, -1, 379, 380, -1, -1, -1, -1, + 385, 386, 387, 388, 389, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 399, 400, 401, 402, 403, 404, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, -1, 26, 27, 28, 29, 30, 31, 32, @@ -2627,11 +2557,212 @@ static const yytype_int16 yycheck[] = 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - -1, -1, 355, 356, -1, -1, -1, -1, -1, -1, + 353, -1, -1, 356, 357, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 374, -1, 376, -1, -1, -1, -1, -1, -1, - -1, 384, 385, 386, 387, 388, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 398, 399, 400, 401, 402, + -1, -1, 375, -1, 377, -1, 379, -1, -1, -1, + -1, -1, 385, 386, 387, 388, 389, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 399, 400, 401, 402, + 403, 404, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, -1, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, + 351, 352, 353, -1, -1, 356, 357, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 375, -1, 377, -1, 379, -1, + -1, -1, -1, -1, 385, 386, 387, 388, 389, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 399, 400, + 401, 402, 403, 404, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, -1, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, + 349, 350, 351, 352, 353, -1, -1, 356, 357, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 375, -1, 377, -1, + -1, -1, -1, -1, -1, -1, 385, 386, 387, 388, + 389, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 399, 400, 401, 402, 403, 404, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, + 337, 338, -1, 340, 341, 342, 343, 344, 345, 346, + 347, 348, 349, 350, 351, 352, 353, -1, -1, 356, + 357, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 375, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 385, 386, + 387, 388, 389, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 399, 400, 401, 402, 403, 404, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 337, 338, -1, -1, 341, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 385, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 399, 400, 401, 402, 403, 404, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, + 333, 334, 335, 336, 337, 338, -1, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, + 353, -1, -1, 356, 357, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 375, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 386, 387, 388, 389, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 399, 400, 401, 402, 403, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, @@ -2665,13 +2796,13 @@ static const yytype_int16 yycheck[] = 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, - 332, 333, 334, 335, 336, 337, -1, 339, 340, 341, - 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, - 352, -1, -1, 355, 356, -1, -1, -1, -1, -1, + 332, 333, 334, 335, 336, 337, 338, -1, 340, 341, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 374, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 384, 385, 386, 387, 388, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 398, 399, 400, 401, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 385, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 399, 400, 401, 402, 403, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, @@ -2705,13 +2836,13 @@ static const yytype_int16 yycheck[] = 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, -1, -1, 340, + 331, 332, 333, 334, 335, 336, 337, 338, -1, -1, + 341, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 380, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 384, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 398, 399, 400, + -1, -1, -1, -1, -1, -1, -1, -1, 399, 400, 401, 402, 403, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, @@ -2745,288 +2876,130 @@ static const yytype_int16 yycheck[] = 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, 335, 336, 337, -1, 339, - 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 351, 352, -1, -1, 355, 356, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 374, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 385, 386, 387, 388, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 398, 399, - 400, 401, 402, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, 335, 336, 337, -1, 339, - 340, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 330, 331, 332, 333, 334, 335, 336, 337, 338, -1, + -1, 341, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 384, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 398, 399, - 400, 401, 402, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, 335, 336, 337, -1, -1, - 340, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 380, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 399, + 400, 401, 402, 403, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + -1, -1, 341, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 379, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 398, 399, - 400, 401, 402, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, 335, 336, 337, -1, -1, - 340, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 380, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 399, 400, 401, 402, 403, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, + 338, -1, -1, 341, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 379, + -1, -1, -1, -1, -1, -1, -1, 5, 6, 7, + 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, + -1, 399, 400, 401, 402, 403, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 82, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 398, 399, - 400, 401, 402, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, 335, 336, 337, -1, -1, - 340, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, + 338, -1, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 350, 351, 352, 353, -1, -1, 356, 357, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 379, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 398, 399, - 400, 401, 402, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, 335, 336, 337, -1, -1, - 340, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 5, 6, 7, 8, 9, -1, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, -1, -1, -1, -1, -1, -1, -1, 398, 399, - 400, 401, 402, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 82, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, -1, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, 352, -1, -1, 355, 356, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 374, -1, -1, -1, 378, 379, -1, - -1, -1, -1, -1, 385, 386, 387, 388, 5, 6, - 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 82, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, -1, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 351, 352, -1, -1, 355, 356, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 374, -1, -1, - 377, -1, -1, -1, -1, -1, -1, -1, 385, 386, - 387, 388, 5, 6, 7, 8, 9, -1, 11, 12, + -1, -1, -1, -1, -1, -1, -1, 375, -1, -1, + -1, 379, 380, -1, -1, -1, -1, -1, 386, 387, + 388, 389, 5, 6, 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 34, 35, 36, 37, 38, 39, 40, 41, 42, @@ -3059,166 +3032,205 @@ static const yytype_int16 yycheck[] = 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, 335, 336, 337, -1, 339, 340, 341, 342, + 333, 334, 335, 336, 337, 338, -1, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - -1, -1, 355, 356, -1, -1, -1, -1, -1, -1, + 353, -1, -1, 356, 357, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 374, -1, -1, -1, 378, -1, -1, -1, -1, - -1, -1, 385, 386, 387, 388, 5, 6, 7, 8, - 9, -1, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 34, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 82, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 98, - 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - 119, 120, 121, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 131, 132, 133, 134, 135, 136, 137, 138, - 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 336, 337, -1, - 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 351, 352, -1, -1, 355, 356, -1, -1, + -1, -1, 375, -1, -1, 378, -1, -1, -1, -1, + -1, -1, -1, 386, 387, 388, 389, 5, 6, 7, + 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 82, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 374, -1, -1, 377, -1, - -1, -1, -1, -1, -1, -1, 385, 386, 387, 388, - 5, 6, 7, 8, 9, -1, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 82, -1, -1, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, + 338, -1, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 350, 351, 352, 353, -1, -1, 356, 357, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 337, -1, 339, 340, 341, 342, 343, 344, - 345, 346, 347, 348, 349, 350, 351, 352, -1, -1, - 355, 356, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 374, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 384, - 385, 386, 387, 388, 5, 6, 7, 8, 9, -1, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 82, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, -1, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, 352, -1, -1, 355, 356, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 375, -1, -1, + -1, 379, -1, -1, -1, -1, -1, -1, 386, 387, + 388, 389, 5, 6, 7, 8, 9, -1, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 374, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 385, 386, 387, 388, 5, 6, - 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 82, -1, -1, -1, -1, + -1, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 82, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, -1, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 351, 352, -1, -1, 355, 356, + -1, -1, -1, -1, -1, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, + 333, 334, 335, 336, 337, 338, -1, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, + 353, -1, -1, 356, 357, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 374, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 385, 386, - 387, 388, 5, 6, 7, 8, 9, -1, 11, 12, + -1, -1, 375, -1, -1, 378, -1, -1, -1, -1, + -1, -1, -1, 386, 387, 388, 389, 5, 6, 7, + 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 82, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, + 338, -1, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 350, 351, 352, 353, -1, -1, 356, 357, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 375, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 385, 386, 387, + 388, 389, 5, 6, 7, 8, 9, -1, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 82, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, + 333, 334, 335, 336, 337, 338, -1, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, + 353, -1, -1, 356, 357, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 375, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 386, 387, 388, 389, 5, 6, 7, + 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 82, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, + 338, -1, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 350, 351, 352, 353, -1, -1, 356, 357, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 375, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 386, 387, + 388, 389, 5, 6, 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 34, 35, 36, 37, 38, 39, 40, 41, 42, @@ -3251,7 +3263,7 @@ static const yytype_int16 yycheck[] = 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, 335, 336, 337, -1, -1, 340 + 333, 334, 335, 336, 337, 338, -1, -1, 341 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing @@ -3290,109 +3302,110 @@ static const yytype_uint16 yystos[] = 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, 335, 336, 337, 340, 384, 398, 399, 400, - 401, 402, 403, 438, 439, 442, 443, 444, 445, 449, - 450, 451, 452, 453, 454, 457, 458, 459, 460, 461, - 463, 465, 466, 467, 507, 508, 509, 374, 374, 339, - 378, 466, 339, 384, 384, 510, 375, 381, 446, 447, - 448, 458, 463, 381, 384, 339, 339, 384, 459, 463, - 376, 464, 0, 508, 339, 462, 81, 339, 455, 456, - 378, 469, 463, 384, 464, 378, 486, 447, 446, 448, - 339, 339, 374, 383, 464, 378, 381, 384, 441, 339, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, 352, 355, 356, 374, 377, 385, 386, 387, 388, - 408, 409, 410, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 430, 431, 432, 461, 463, 376, 375, 381, 383, - 375, 381, 468, 458, 463, 470, 471, 384, 384, 22, - 23, 24, 26, 27, 28, 29, 30, 31, 32, 338, - 376, 378, 379, 384, 419, 432, 434, 436, 438, 442, - 461, 463, 476, 477, 478, 479, 487, 488, 489, 490, - 493, 494, 497, 498, 499, 506, 511, 464, 383, 464, - 378, 434, 474, 383, 440, 339, 381, 384, 419, 419, - 436, 355, 356, 376, 380, 375, 375, 381, 337, 434, - 374, 419, 389, 390, 391, 386, 388, 353, 354, 357, - 358, 392, 393, 359, 360, 396, 395, 394, 361, 363, - 362, 397, 377, 377, 432, 339, 432, 437, 456, 470, - 463, 339, 472, 473, 379, 471, 384, 384, 501, 374, - 374, 384, 384, 436, 374, 436, 382, 374, 376, 379, - 480, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 383, 435, 381, 384, 379, 477, 490, 494, 499, - 474, 383, 474, 475, 474, 470, 339, 375, 411, 436, - 339, 434, 419, 419, 419, 421, 421, 422, 422, 423, - 423, 423, 423, 424, 424, 425, 426, 427, 428, 429, - 430, 433, 377, 379, 472, 464, 381, 384, 477, 502, - 436, 384, 436, 382, 500, 339, 512, 513, 487, 434, - 434, 474, 379, 381, 379, 377, 436, 384, 473, 338, - 476, 488, 503, 375, 375, 436, 451, 458, 492, 374, - 377, 381, 481, 379, 474, 382, 374, 492, 504, 505, - 483, 484, 485, 491, 495, 339, 375, 437, 377, 513, - 379, 434, 436, 384, 375, 25, 479, 478, 378, 383, - 478, 482, 486, 375, 375, 436, 482, 483, 487, 496, - 474, 384, 379 + 333, 334, 335, 336, 337, 338, 341, 385, 399, 400, + 401, 402, 403, 404, 439, 440, 443, 444, 445, 446, + 450, 451, 452, 453, 454, 455, 458, 459, 460, 461, + 462, 464, 469, 470, 471, 511, 512, 513, 375, 375, + 340, 379, 470, 340, 385, 385, 514, 376, 382, 447, + 448, 449, 459, 464, 382, 385, 340, 340, 385, 460, + 464, 393, 466, 467, 0, 512, 340, 463, 81, 340, + 456, 457, 379, 473, 464, 377, 385, 465, 379, 490, + 448, 447, 449, 340, 340, 375, 384, 465, 379, 382, + 385, 442, 340, 342, 343, 344, 345, 346, 347, 348, + 349, 350, 351, 352, 353, 356, 357, 375, 386, 387, + 388, 389, 409, 410, 411, 413, 414, 415, 416, 417, + 418, 419, 420, 421, 462, 464, 468, 465, 376, 382, + 384, 376, 382, 472, 459, 464, 474, 475, 385, 378, + 420, 422, 423, 424, 425, 426, 427, 428, 429, 430, + 431, 432, 433, 377, 385, 22, 23, 24, 26, 27, + 28, 29, 30, 31, 32, 339, 377, 379, 380, 385, + 420, 433, 435, 437, 439, 443, 462, 464, 480, 481, + 482, 483, 491, 492, 493, 494, 497, 498, 501, 502, + 503, 510, 515, 465, 384, 465, 379, 435, 478, 384, + 441, 340, 382, 385, 420, 420, 437, 356, 357, 377, + 381, 376, 376, 382, 338, 435, 375, 420, 382, 394, + 340, 433, 438, 457, 474, 464, 340, 476, 477, 380, + 475, 390, 391, 392, 387, 389, 354, 355, 358, 359, + 393, 394, 360, 361, 397, 396, 395, 362, 364, 363, + 398, 378, 378, 433, 385, 385, 505, 375, 375, 385, + 385, 437, 375, 437, 383, 375, 377, 380, 484, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 384, + 436, 382, 385, 380, 481, 494, 498, 503, 478, 384, + 478, 479, 478, 474, 340, 376, 412, 437, 340, 435, + 420, 380, 476, 465, 382, 385, 420, 420, 420, 422, + 422, 423, 423, 424, 424, 424, 424, 425, 425, 426, + 427, 428, 429, 430, 431, 434, 378, 481, 506, 437, + 385, 437, 383, 504, 340, 516, 517, 491, 435, 435, + 478, 380, 382, 380, 378, 385, 477, 437, 339, 480, + 492, 507, 376, 376, 437, 452, 459, 496, 375, 378, + 382, 485, 380, 478, 383, 375, 496, 508, 509, 487, + 488, 489, 495, 499, 340, 376, 438, 378, 517, 380, + 435, 437, 385, 376, 25, 483, 482, 379, 384, 482, + 486, 490, 376, 376, 437, 486, 487, 491, 500, 478, + 385, 380 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint16 yyr1[] = { - 0, 407, 408, 409, 409, 409, 409, 409, 409, 409, - 409, 409, 409, 409, 409, 409, 409, 410, 410, 410, - 410, 410, 410, 411, 412, 413, 414, 414, 415, 415, - 416, 416, 417, 418, 418, 418, 419, 419, 419, 419, - 420, 420, 420, 420, 421, 421, 421, 421, 422, 422, - 422, 423, 423, 423, 424, 424, 424, 424, 424, 425, - 425, 425, 426, 426, 427, 427, 428, 428, 429, 429, - 430, 430, 431, 431, 432, 433, 432, 434, 434, 435, - 435, 435, 435, 435, 435, 435, 435, 435, 435, 435, - 436, 436, 437, 438, 438, 438, 438, 438, 438, 438, - 438, 438, 440, 439, 441, 441, 442, 443, 443, 444, - 444, 445, 446, 446, 447, 447, 447, 447, 448, 449, - 449, 449, 449, 449, 450, 450, 450, 450, 450, 451, - 451, 452, 453, 453, 453, 453, 453, 453, 453, 453, - 454, 455, 455, 456, 456, 456, 457, 458, 458, 459, - 459, 459, 459, 459, 459, 459, 460, 460, 460, 460, - 460, 460, 460, 460, 460, 460, 460, 460, 460, 460, - 460, 460, 460, 460, 460, 460, 460, 460, 460, 460, - 460, 460, 460, 460, 460, 461, 462, 462, 463, 463, - 464, 464, 464, 464, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, - 465, 466, 466, 466, 468, 467, 469, 467, 470, 470, - 471, 471, 472, 472, 473, 473, 474, 474, 474, 475, - 475, 476, 477, 477, 478, 478, 478, 478, 478, 478, - 478, 479, 480, 481, 479, 482, 482, 484, 483, 485, - 483, 486, 486, 487, 487, 488, 488, 489, 489, 490, - 491, 491, 492, 492, 493, 493, 495, 494, 496, 496, - 497, 497, 498, 498, 500, 499, 501, 499, 502, 499, - 503, 503, 504, 504, 505, 505, 506, 506, 506, 506, - 506, 507, 507, 508, 508, 508, 510, 509, 511, 512, - 512, 513, 513 + 0, 408, 409, 410, 410, 410, 410, 410, 410, 410, + 410, 410, 410, 410, 410, 410, 410, 411, 411, 411, + 411, 411, 411, 412, 413, 414, 415, 415, 416, 416, + 417, 417, 418, 419, 419, 419, 420, 420, 420, 420, + 421, 421, 421, 421, 422, 422, 422, 422, 423, 423, + 423, 424, 424, 424, 425, 425, 425, 425, 425, 426, + 426, 426, 427, 427, 428, 428, 429, 429, 430, 430, + 431, 431, 432, 432, 433, 434, 433, 435, 435, 436, + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, + 437, 437, 438, 439, 439, 439, 439, 439, 439, 439, + 439, 439, 441, 440, 442, 442, 443, 444, 444, 445, + 445, 446, 447, 447, 448, 448, 448, 448, 449, 450, + 450, 450, 450, 450, 451, 451, 451, 451, 451, 452, + 452, 453, 454, 454, 454, 454, 454, 454, 454, 454, + 455, 456, 456, 457, 457, 457, 458, 459, 459, 460, + 460, 460, 460, 460, 460, 460, 461, 461, 461, 461, + 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, + 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, + 461, 461, 461, 461, 461, 462, 463, 463, 464, 464, + 465, 465, 465, 465, 466, 466, 467, 468, 468, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + 469, 469, 469, 469, 469, 469, 469, 470, 470, 470, + 472, 471, 473, 471, 474, 474, 475, 475, 476, 476, + 477, 477, 478, 478, 478, 479, 479, 480, 481, 481, + 482, 482, 482, 482, 482, 482, 482, 483, 484, 485, + 483, 486, 486, 488, 487, 489, 487, 490, 490, 491, + 491, 492, 492, 493, 493, 494, 495, 495, 496, 496, + 497, 497, 499, 498, 500, 500, 501, 501, 502, 502, + 504, 503, 505, 503, 506, 503, 507, 507, 508, 508, + 509, 509, 510, 510, 510, 510, 510, 511, 511, 512, + 512, 512, 514, 513, 515, 516, 516, 517, 517 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ @@ -3416,8 +3429,8 @@ static const yytype_uint8 yyr2[] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 4, 1, 1, 3, 1, 2, - 2, 3, 3, 4, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 4, 1, 1, 3, 2, 3, + 2, 3, 3, 4, 1, 0, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -3446,16 +3459,16 @@ static const yytype_uint8 yyr2[] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 0, 6, 0, 5, 1, 2, - 3, 4, 1, 3, 1, 2, 1, 3, 4, 1, - 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 2, 0, 0, 5, 1, 1, 0, 2, 0, - 2, 2, 3, 1, 2, 1, 2, 1, 2, 5, - 3, 1, 1, 4, 1, 2, 0, 8, 0, 1, - 3, 2, 1, 2, 0, 6, 0, 8, 0, 7, - 1, 1, 1, 0, 2, 3, 2, 2, 2, 3, - 2, 1, 2, 1, 1, 1, 0, 3, 5, 1, - 3, 1, 4 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 6, 0, 5, 1, 2, 3, 4, 1, 3, + 1, 2, 1, 3, 4, 1, 3, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, + 5, 1, 1, 0, 2, 0, 2, 2, 3, 1, + 2, 1, 2, 1, 2, 5, 3, 1, 1, 4, + 1, 2, 0, 8, 0, 1, 3, 2, 1, 2, + 0, 6, 0, 8, 0, 7, 1, 1, 1, 0, + 2, 3, 2, 2, 2, 3, 2, 1, 2, 1, + 1, 1, 0, 3, 5, 1, 3, 1, 4 }; @@ -4138,250 +4151,250 @@ yyreduce: switch (yyn) { case 2: -#line 296 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 302 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string); } -#line 4146 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4159 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 3: -#line 302 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 308 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4154 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4167 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 4: -#line 305 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 311 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 4163 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4176 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 5: -#line 309 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 315 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 4172 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4185 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 6: -#line 313 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 319 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 4180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4193 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 7: -#line 316 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 322 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 4189 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 8: -#line 320 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 326 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true); } -#line 4198 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4211 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 9: -#line 324 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 330 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true); } -#line 4207 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4220 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 10: -#line 328 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 334 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 4216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4229 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 11: -#line 332 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 338 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 4225 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4238 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 12: -#line 336 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 342 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 4233 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 13: -#line 339 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 345 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtDouble, (yyvsp[0].lex).loc, true); } -#line 4242 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4255 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 14: -#line 343 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 349 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true); } -#line 4251 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 15: -#line 347 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 353 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 4259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4272 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 16: -#line 350 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 356 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); if ((yyval.interm.intermTypedNode)->getAsConstantUnion()) (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } -#line 4269 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4282 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 17: -#line 358 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); - } -#line 4277 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 18: -#line 361 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode)); - } -#line 4285 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 19: #line 364 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4293 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4290 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 18: +#line 367 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode)); + } +#line 4298 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 19: +#line 370 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); + } +#line 4306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 20: -#line 367 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 373 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string); } -#line 4301 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4314 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 21: -#line 370 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 376 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode)); } -#line 4311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4324 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 22: -#line 375 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 381 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode)); } -#line 4321 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4334 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 23: -#line 383 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 389 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]"); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4330 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 24: -#line 390 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 396 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode); delete (yyvsp[0].interm).function; } -#line 4339 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4352 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 25: -#line 397 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 403 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); } -#line 4347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4360 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 26: -#line 403 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 409 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-1].interm); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 4356 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4369 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 27: -#line 407 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 413 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-1].interm); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 4365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4378 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 28: -#line 414 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 420 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-1].interm); } -#line 4373 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 29: -#line 417 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 423 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); } -#line 4381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4394 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 30: -#line 423 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 429 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { TParameter param = { 0, new TType }; param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType()); @@ -4389,11 +4402,11 @@ yyreduce: (yyval.interm).function = (yyvsp[-1].interm).function; (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode); } -#line 4393 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 31: -#line 430 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 436 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { TParameter param = { 0, new TType }; param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType()); @@ -4401,29 +4414,29 @@ yyreduce: (yyval.interm).function = (yyvsp[-2].interm).function; (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); } -#line 4405 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4418 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 32: -#line 440 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 446 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-1].interm); } -#line 4413 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 33: -#line 448 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 454 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // Constructor (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 4423 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 34: -#line 453 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 459 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // // Should be a method or subroutine call, but we haven't recognized the arguments yet. @@ -4451,50 +4464,50 @@ yyreduce: (yyval.interm).function = new TFunction(empty, TType(EbtVoid), EOpNull); } } -#line 4455 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4468 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 35: -#line 480 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 486 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // Constructor (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 4465 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4478 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 36: -#line 488 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 494 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.variableCheck((yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode()) parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), ""); } -#line 4476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 37: -#line 494 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 500 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode)); } -#line 4485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4498 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 38: -#line 498 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 504 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode)); } -#line 4494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4507 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 39: -#line 502 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 508 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-1].interm).op != EOpNull) { char errorOp[2] = {0, 0}; @@ -4511,179 +4524,179 @@ yyreduce: (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } } -#line 4515 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4528 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 40: -#line 522 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 528 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; } -#line 4521 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4534 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 41: -#line 523 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 529 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; } -#line 4527 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 42: -#line 524 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; } -#line 4533 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 43: -#line 525 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot; - parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); } #line 4540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 44: -#line 531 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } + case 42: +#line 530 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; } #line 4546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; + case 43: +#line 531 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot; + parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); } +#line 4553 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 44: +#line 537 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } +#line 4559 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + case 45: -#line 532 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 538 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "*", EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4569 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 46: -#line 537 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 543 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "/", EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 47: -#line 542 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 548 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "%"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "%", EOpMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4577 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4590 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 48: -#line 551 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 557 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4583 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 49: -#line 552 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 558 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "+", EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4593 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 50: -#line 557 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 563 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "-", EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4603 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4616 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 51: -#line 565 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 571 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4609 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4622 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 52: -#line 566 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 572 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift left"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<<", EOpLeftShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4620 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4633 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 53: -#line 572 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 578 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift right"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">>", EOpRightShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4644 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 54: -#line 581 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 587 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4637 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 55: -#line 582 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 588 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<", EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4647 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4660 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 56: -#line 587 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 593 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">", EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4657 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4670 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 57: -#line 592 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 598 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<=", EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4667 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4680 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 58: -#line 597 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 603 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4677 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 59: -#line 605 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 611 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4696 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 60: -#line 606 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 612 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=="); @@ -4692,11 +4705,11 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4696 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 61: -#line 614 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 620 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!="); @@ -4705,124 +4718,124 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4722 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 62: -#line 625 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 631 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4715 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4728 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 63: -#line 626 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 632 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise and"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&", EOpAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4726 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4739 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 64: -#line 635 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 641 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4745 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 65: -#line 636 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 642 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise exclusive or"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^", EOpExclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4756 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 66: -#line 645 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 651 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4749 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 67: -#line 646 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 652 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise inclusive or"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "|", EOpInclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4760 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4773 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 68: -#line 655 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 661 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4766 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4779 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 69: -#line 656 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 662 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&&", EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4776 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4789 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 70: -#line 664 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 670 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 71: -#line 665 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 671 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^^", EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4792 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4805 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 72: -#line 673 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 679 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4798 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4811 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 73: -#line 674 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 680 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "||", EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4808 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4821 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 74: -#line 682 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 688 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4814 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4827 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 75: -#line 683 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 689 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { ++parseContext.controlFlowNestingLevel; } -#line 4822 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4835 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 76: -#line 686 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 692 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { --parseContext.controlFlowNestingLevel; parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode)); @@ -4835,17 +4848,17 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 4839 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4852 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 77: -#line 701 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 707 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4845 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4858 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 78: -#line 702 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 708 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment"); parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "="); @@ -4859,119 +4872,119 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } } -#line 4863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4876 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 79: -#line 718 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 724 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAssign; } -#line 4872 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 80: -#line 722 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 728 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpMulAssign; } -#line 4881 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4894 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 81: -#line 726 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 732 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpDivAssign; } -#line 4890 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4903 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 82: -#line 730 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 736 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%="); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpModAssign; } -#line 4900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 83: -#line 735 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 741 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAddAssign; } -#line 4909 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 84: -#line 739 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 745 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpSubAssign; } -#line 4918 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4931 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 85: -#line 743 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 749 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign; } -#line 4927 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 86: -#line 747 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 753 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign; } -#line 4936 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 87: -#line 751 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 757 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign; } -#line 4945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 88: -#line 755 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 761 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign; } -#line 4954 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4967 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 89: -#line 759 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 765 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign; } -#line 4963 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4976 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 90: -#line 766 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 772 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4971 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4984 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 91: -#line 769 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 775 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.samplerConstructorLocationCheck((yyvsp[-1].lex).loc, ",", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); @@ -4980,40 +4993,40 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 4984 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4997 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 92: -#line 780 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 786 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), ""); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4993 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 93: -#line 787 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 793 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */); (yyval.interm.intermNode) = 0; // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature } -#line 5003 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5016 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 94: -#line 792 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 798 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-1].interm).intermNode && (yyvsp[-1].interm).intermNode->getAsAggregate()) (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence); (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode; } -#line 5013 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 95: -#line 797 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 803 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement"); @@ -5022,75 +5035,75 @@ yyreduce: parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision); (yyval.interm.intermNode) = 0; } -#line 5026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 96: -#line 805 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 811 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList); (yyval.interm.intermNode) = 0; } -#line 5035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 97: -#line 809 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 815 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string); (yyval.interm.intermNode) = 0; } -#line 5044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5057 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 98: -#line 813 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 819 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes); (yyval.interm.intermNode) = 0; } -#line 5053 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 99: -#line 817 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 823 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier); parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type)); (yyval.interm.intermNode) = 0; } -#line 5063 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5076 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 100: -#line 822 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 828 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.checkNoShaderLayouts((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).shaderQualifiers); parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].lex).string); (yyval.interm.intermNode) = 0; } -#line 5073 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5086 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 101: -#line 827 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 833 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.checkNoShaderLayouts((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).shaderQualifiers); (yyvsp[-1].interm.identifierList)->push_back((yyvsp[-2].lex).string); parseContext.addQualifierToExisting((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier, *(yyvsp[-1].interm.identifierList)); (yyval.interm.intermNode) = 0; } -#line 5084 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5097 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 102: -#line 836 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 842 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); } -#line 5090 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5103 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 103: -#line 836 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 842 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { --parseContext.structNestingLevel; parseContext.blockName = (yyvsp[-4].lex).string; @@ -5100,54 +5113,54 @@ yyreduce: (yyval.interm).loc = (yyvsp[-5].interm.type).loc; (yyval.interm).typeList = (yyvsp[-1].interm.typeList); } -#line 5104 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5117 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 104: -#line 847 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 853 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.identifierList) = new TIdentifierList; (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 5113 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5126 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 105: -#line 851 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 857 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList); (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 5122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5135 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 106: -#line 858 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 864 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).function = (yyvsp[-1].interm.function); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 5131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 107: -#line 865 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 871 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 5139 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5152 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 108: -#line 868 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 874 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 5147 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 109: -#line 875 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 881 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // Add the parameter (yyval.interm.function) = (yyvsp[-1].interm.function); @@ -5156,11 +5169,11 @@ yyreduce: else delete (yyvsp[0].interm).param.type; } -#line 5160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5173 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 110: -#line 883 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 889 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // // Only first parameter of one-parameter functions can be void @@ -5178,11 +5191,11 @@ yyreduce: (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param); } } -#line 5182 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5195 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 111: -#line 903 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 909 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-2].interm.type).qualifier.storage != EvqGlobal && (yyvsp[-2].interm.type).qualifier.storage != EvqTemporary) { parseContext.error((yyvsp[-1].lex).loc, "no qualifiers allowed for function return", @@ -5202,11 +5215,11 @@ yyreduce: function = new TFunction((yyvsp[-1].lex).string, type); (yyval.interm.function) = function; } -#line 5206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5219 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 112: -#line 926 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 932 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-1].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -5222,11 +5235,11 @@ yyreduce: (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).param = param; } -#line 5226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5239 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 113: -#line 941 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 947 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -5246,11 +5259,11 @@ yyreduce: (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).param = param; } -#line 5250 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5263 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 114: -#line 966 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 972 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) @@ -5262,11 +5275,11 @@ yyreduce: parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); } -#line 5266 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5279 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 115: -#line 977 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 983 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); @@ -5274,11 +5287,11 @@ yyreduce: parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier()); } -#line 5278 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5291 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 116: -#line 987 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 993 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) @@ -5289,11 +5302,11 @@ yyreduce: parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type); parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); } -#line 5293 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 117: -#line 997 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1003 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); @@ -5301,118 +5314,118 @@ yyreduce: parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier()); } -#line 5305 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5318 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 118: -#line 1007 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1013 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { TParameter param = { 0, new TType((yyvsp[0].interm.type)) }; (yyval.interm).param = param; if ((yyvsp[0].interm.type).arraySizes) parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes); } -#line 5316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5329 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 119: -#line 1016 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1022 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); } -#line 5324 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5337 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 120: -#line 1019 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1025 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-2].interm); parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type); } -#line 5333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5346 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 121: -#line 1023 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1029 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-3].interm); parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes); } -#line 5342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5355 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 122: -#line 1027 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1033 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[-5].interm).type; TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-5].interm).type, (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-5].interm).intermNode, initNode, (yyvsp[-1].lex).loc); } -#line 5352 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 123: -#line 1032 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1038 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[-4].interm).type; TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-4].interm).type, 0, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-4].interm).intermNode, initNode, (yyvsp[-1].lex).loc); } -#line 5362 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 124: -#line 1040 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1046 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[0].interm.type); (yyval.interm).intermNode = 0; parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type); } -#line 5372 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5385 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 125: -#line 1045 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1051 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[-1].interm.type); (yyval.interm).intermNode = 0; parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type)); } -#line 5382 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5395 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 126: -#line 1050 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1056 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[-2].interm.type); (yyval.interm).intermNode = 0; parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes); } -#line 5392 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5405 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 127: -#line 1055 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1061 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[-4].interm.type); TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-4].interm.type), (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); } -#line 5402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5415 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 128: -#line 1060 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1066 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[-3].interm.type); TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); } -#line 5412 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5425 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 129: -#line 1069 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1075 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); @@ -5424,11 +5437,11 @@ yyreduce: parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier); } -#line 5428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 130: -#line 1080 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1086 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier); parseContext.globalQualifierTypeCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, (yyvsp[0].interm.type)); @@ -5453,22 +5466,22 @@ yyreduce: (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn))) (yyval.interm.type).qualifier.smooth = true; } -#line 5457 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5470 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 131: -#line 1107 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1113 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "invariant"); parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.invariant = true; } -#line 5468 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5481 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 132: -#line 1116 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1122 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "smooth"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth"); @@ -5476,11 +5489,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.smooth = true; } -#line 5480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5493 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 133: -#line 1123 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1129 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "flat"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat"); @@ -5488,11 +5501,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.flat = true; } -#line 5492 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 134: -#line 1130 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1136 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective"); #ifdef NV_EXTENSIONS @@ -5504,11 +5517,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nopersp = true; } -#line 5508 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5521 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 135: -#line 1141 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1147 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD"); @@ -5518,11 +5531,11 @@ yyreduce: (yyval.interm.type).qualifier.explicitInterp = true; #endif } -#line 5522 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5535 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 136: -#line 1150 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1156 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef NV_EXTENSIONS parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexNV"); @@ -5533,11 +5546,11 @@ yyreduce: (yyval.interm.type).qualifier.pervertexNV = true; #endif } -#line 5537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5550 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 137: -#line 1160 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1166 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef NV_EXTENSIONS // No need for profile version or extension check. Shader stage already checks both. @@ -5550,11 +5563,11 @@ yyreduce: (yyval.interm.type).qualifier.perPrimitiveNV = true; #endif } -#line 5554 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 138: -#line 1172 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1178 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef NV_EXTENSIONS // No need for profile version or extension check. Shader stage already checks both. @@ -5564,11 +5577,11 @@ yyreduce: (yyval.interm.type).qualifier.perViewNV = true; #endif } -#line 5568 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5581 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 139: -#line 1181 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1187 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef NV_EXTENSIONS // No need for profile version or extension check. Shader stage already checks both. @@ -5578,84 +5591,84 @@ yyreduce: (yyval.interm.type).qualifier.perTaskNV = true; #endif } -#line 5582 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5595 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 140: -#line 1193 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1199 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[-1].interm.type); } -#line 5590 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5603 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 141: -#line 1199 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1205 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5598 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5611 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 142: -#line 1202 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1208 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[-2].interm.type); (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); } -#line 5608 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5621 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 143: -#line 1209 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1215 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string); } -#line 5617 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5630 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 144: -#line 1213 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1219 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[-2].lex).loc); parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode)); } -#line 5626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5639 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 145: -#line 1217 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1223 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // because "shared" is both an identifier and a keyword (yyval.interm.type).init((yyvsp[0].lex).loc); TString strShared("shared"); parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared); } -#line 5636 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5649 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 146: -#line 1225 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1231 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.noContraction = true; } -#line 5647 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5660 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 147: -#line 1234 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1240 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5655 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 148: -#line 1237 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1243 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[-1].interm.type); if ((yyval.interm.type).basicType == EbtVoid) @@ -5664,80 +5677,80 @@ yyreduce: (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); parseContext.mergeQualifiers((yyval.interm.type).loc, (yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); } -#line 5668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 149: -#line 1248 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1254 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5676 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5689 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 150: -#line 1251 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1257 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5684 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 151: -#line 1254 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1260 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5693 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5706 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 152: -#line 1258 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1264 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5702 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5715 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 153: -#line 1262 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1268 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5724 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 154: -#line 1266 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1272 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5720 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5733 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 155: -#line 1270 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1276 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5728 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 156: -#line 1276 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1282 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqConst; // will later turn into EvqConstReadOnly, if the initializer is not constant } -#line 5737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5750 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 157: -#line 1280 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1286 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute"); @@ -5750,11 +5763,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 5754 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5767 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 158: -#line 1292 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1298 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying"); @@ -5769,43 +5782,43 @@ yyreduce: else (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 5773 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5786 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 159: -#line 1306 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1312 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "inout"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqInOut; } -#line 5783 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5796 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 160: -#line 1311 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1317 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "in"); (yyval.interm.type).init((yyvsp[0].lex).loc); // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later (yyval.interm.type).qualifier.storage = EvqIn; } -#line 5794 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5807 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 161: -#line 1317 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1323 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "out"); (yyval.interm.type).init((yyvsp[0].lex).loc); // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later (yyval.interm.type).qualifier.storage = EvqOut; } -#line 5805 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5818 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 162: -#line 1323 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1329 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid"); @@ -5813,52 +5826,52 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.centroid = true; } -#line 5817 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5830 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 163: -#line 1330 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1336 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "patch"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.patch = true; } -#line 5828 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5841 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 164: -#line 1336 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1342 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "sample"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.sample = true; } -#line 5838 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5851 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 165: -#line 1341 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1347 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "uniform"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqUniform; } -#line 5848 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5861 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 166: -#line 1346 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1352 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "buffer"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqBuffer; } -#line 5858 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5871 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 167: -#line 1351 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1357 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef NV_EXTENSIONS parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV"); @@ -5869,11 +5882,11 @@ yyreduce: (yyval.interm.type).qualifier.storage = EvqHitAttrNV; #endif } -#line 5873 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5886 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 168: -#line 1361 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1367 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef NV_EXTENSIONS parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV"); @@ -5884,11 +5897,11 @@ yyreduce: (yyval.interm.type).qualifier.storage = EvqPayloadNV; #endif } -#line 5888 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5901 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 169: -#line 1371 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1377 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef NV_EXTENSIONS parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV"); @@ -5899,11 +5912,11 @@ yyreduce: (yyval.interm.type).qualifier.storage = EvqPayloadInNV; #endif } -#line 5903 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5916 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 170: -#line 1381 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1387 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef NV_EXTENSIONS parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV"); @@ -5914,11 +5927,11 @@ yyreduce: (yyval.interm.type).qualifier.storage = EvqCallableDataNV; #endif } -#line 5918 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5931 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 171: -#line 1391 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1397 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef NV_EXTENSIONS parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV"); @@ -5928,11 +5941,11 @@ yyreduce: (yyval.interm.type).qualifier.storage = EvqCallableDataInNV; #endif } -#line 5932 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 172: -#line 1400 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1406 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "shared"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared"); @@ -5945,1764 +5958,1749 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqShared; } -#line 5949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 173: -#line 1412 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1418 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.coherent = true; } -#line 5958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5971 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 174: -#line 1416 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1422 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent"); (yyval.interm.type).qualifier.devicecoherent = true; } -#line 5968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5981 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 175: -#line 1421 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1427 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent"); (yyval.interm.type).qualifier.queuefamilycoherent = true; } -#line 5978 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5991 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 176: -#line 1426 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1432 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent"); (yyval.interm.type).qualifier.workgroupcoherent = true; } -#line 5988 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 177: -#line 1431 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1437 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent"); (yyval.interm.type).qualifier.subgroupcoherent = true; } -#line 5998 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6011 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 178: -#line 1436 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1442 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "nonprivate"); (yyval.interm.type).qualifier.nonprivate = true; } -#line 6008 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 179: -#line 1441 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1447 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.volatil = true; } -#line 6017 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6030 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 180: -#line 1445 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1451 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.restrict = true; } -#line 6026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 181: -#line 1449 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1455 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.readonly = true; } -#line 6035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 182: -#line 1453 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1459 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.writeonly = true; } -#line 6044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6057 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 183: -#line 1457 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1463 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.spvRemoved((yyvsp[0].lex).loc, "subroutine"); parseContext.globalCheck((yyvsp[0].lex).loc, "subroutine"); parseContext.unimplemented((yyvsp[0].lex).loc, "subroutine"); (yyval.interm.type).init((yyvsp[0].lex).loc); } -#line 6055 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6068 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 184: -#line 1463 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1469 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.spvRemoved((yyvsp[-3].lex).loc, "subroutine"); parseContext.globalCheck((yyvsp[-3].lex).loc, "subroutine"); parseContext.unimplemented((yyvsp[-3].lex).loc, "subroutine"); (yyval.interm.type).init((yyvsp[-3].lex).loc); } -#line 6066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6079 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 185: -#line 1472 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1478 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nonUniform = true; } -#line 6075 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6088 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 186: -#line 1479 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1485 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // TODO } -#line 6083 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6096 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 187: -#line 1482 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1488 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // TODO: 4.0 semantics: subroutines // 1) make sure each identifier is a type declared earlier with SUBROUTINE // 2) save all of the identifiers for future comparison with the declared function } -#line 6093 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6106 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 188: -#line 1490 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1496 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - (yyval.interm.type) = (yyvsp[0].interm.type); + (yyval.interm.type) = (yyvsp[-1].interm.type); (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); + (yyval.interm.type).typeParameters = (yyvsp[0].interm.typeParameters); } -#line 6102 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6116 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 189: -#line 1494 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1501 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes); - (yyval.interm.type) = (yyvsp[-1].interm.type); + (yyval.interm.type) = (yyvsp[-2].interm.type); (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); + (yyval.interm.type).typeParameters = (yyvsp[-1].interm.typeParameters); (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes; } -#line 6113 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6128 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 190: -#line 1503 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1511 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).arraySizes = new TArraySizes; (yyval.interm).arraySizes->addInnerSize(); } -#line 6123 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6138 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 191: -#line 1508 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1516 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[-2].lex).loc; (yyval.interm).arraySizes = new TArraySizes; TArraySize size; - parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size); + parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size"); (yyval.interm).arraySizes->addInnerSize(size); } -#line 6136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6151 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 192: -#line 1516 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1524 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-2].interm); (yyval.interm).arraySizes->addInnerSize(); } -#line 6145 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 193: -#line 1520 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1528 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-3].interm); TArraySize size; - parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size); + parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size"); (yyval.interm).arraySizes->addInnerSize(size); } -#line 6157 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6172 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 194: -#line 1530 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1538 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.typeParameters) = (yyvsp[0].interm.typeParameters); + } +#line 6180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 195: +#line 1541 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.typeParameters) = 0; + } +#line 6188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 196: +#line 1547 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.typeParameters) = (yyvsp[-1].interm.typeParameters); + } +#line 6196 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 197: +#line 1553 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.typeParameters) = new TArraySizes; + + TArraySize size; + parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter"); + (yyval.interm.typeParameters)->addInnerSize(size); + } +#line 6208 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 198: +#line 1560 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.typeParameters) = (yyvsp[-2].interm.typeParameters); + + TArraySize size; + parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter"); + (yyval.interm.typeParameters)->addInnerSize(size); + } +#line 6220 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 199: +#line 1570 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtVoid; } -#line 6166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6229 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 195: -#line 1534 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 200: +#line 1574 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } -#line 6175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6238 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 196: -#line 1538 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 201: +#line 1578 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; } -#line 6185 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6248 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 197: -#line 1543 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 202: +#line 1583 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "float16_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; } -#line 6195 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6258 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 198: -#line 1548 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 203: +#line 1588 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } -#line 6205 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6268 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 199: -#line 1553 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 204: +#line 1593 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; } -#line 6215 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6278 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 200: -#line 1558 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 205: +#line 1598 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } -#line 6224 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6287 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 201: -#line 1562 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 206: +#line 1602 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; } -#line 6234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6297 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 202: -#line 1567 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 207: +#line 1607 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; } -#line 6244 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 203: -#line 1572 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 208: +#line 1612 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; } -#line 6254 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6317 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 204: -#line 1577 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 209: +#line 1617 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; } -#line 6264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6327 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 205: -#line 1582 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 210: +#line 1622 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; } -#line 6274 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6337 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 206: -#line 1587 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 211: +#line 1627 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } -#line 6284 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 207: -#line 1592 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 212: +#line 1632 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; } -#line 6294 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6357 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 208: -#line 1597 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 213: +#line 1637 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; } -#line 6304 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6367 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 209: -#line 1602 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 214: +#line 1642 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; } -#line 6314 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 210: -#line 1607 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtBool; - } -#line 6323 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 211: -#line 1611 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setVector(2); - } -#line 6333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 212: -#line 1616 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setVector(3); - } -#line 6343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 213: -#line 1621 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setVector(4); - } -#line 6353 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 214: -#line 1626 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(2); - } -#line 6364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6377 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 215: -#line 1632 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1647 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(3); - } -#line 6375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 216: -#line 1638 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(4); + (yyval.interm.type).basicType = EbtBool; } #line 6386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 217: -#line 1644 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 216: +#line 1651 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat16; + (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(2); } -#line 6397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6396 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 217: +#line 1656 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setVector(3); + } +#line 6406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 218: -#line 1650 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1661 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setVector(3); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setVector(4); } -#line 6408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6416 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 219: -#line 1656 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1666 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setVector(2); + } +#line 6427 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 220: +#line 1672 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setVector(3); + } +#line 6438 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 221: +#line 1678 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setVector(4); + } +#line 6449 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 222: +#line 1684 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat16; + (yyval.interm.type).setVector(2); + } +#line 6460 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 223: +#line 1690 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat16; + (yyval.interm.type).setVector(3); + } +#line 6471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 224: +#line 1696 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setVector(4); } -#line 6419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 220: -#line 1662 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setVector(2); - } -#line 6430 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 221: -#line 1668 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setVector(3); - } -#line 6441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 222: -#line 1674 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setVector(4); - } -#line 6452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 223: -#line 1680 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(2); - } -#line 6463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 224: -#line 1686 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(3); - } -#line 6474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6482 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 225: -#line 1692 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1702 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); + parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(4); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setVector(2); } -#line 6485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6493 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 226: -#line 1698 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1708 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { + parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtBool; - (yyval.interm.type).setVector(2); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setVector(3); } -#line 6495 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6504 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 227: -#line 1703 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1714 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { + parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtBool; - (yyval.interm.type).setVector(3); - } -#line 6505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 228: -#line 1708 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtBool; + (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(4); } #line 6515 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 229: -#line 1713 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 228: +#line 1720 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { + parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(2); } -#line 6525 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 229: +#line 1726 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setVector(3); + } +#line 6537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 230: -#line 1718 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1732 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { + parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt; - (yyval.interm.type).setVector(3); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setVector(4); } -#line 6535 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6548 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 231: -#line 1723 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1738 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt; - (yyval.interm.type).setVector(4); + (yyval.interm.type).basicType = EbtBool; + (yyval.interm.type).setVector(2); } -#line 6545 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6558 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 232: -#line 1728 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1743 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt8; - (yyval.interm.type).setVector(2); + (yyval.interm.type).basicType = EbtBool; + (yyval.interm.type).setVector(3); } -#line 6556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6568 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 233: -#line 1734 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1748 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt8; - (yyval.interm.type).setVector(3); - } -#line 6567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 234: -#line 1740 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt8; + (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(4); } #line 6578 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 235: -#line 1746 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 234: +#line 1753 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt16; + (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(2); } -#line 6589 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6588 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 235: +#line 1758 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).setVector(3); + } +#line 6598 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 236: -#line 1752 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1763 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt16; - (yyval.interm.type).setVector(3); + (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).setVector(4); } -#line 6600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6608 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 237: -#line 1758 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1768 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt8; + (yyval.interm.type).setVector(2); + } +#line 6619 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 238: +#line 1774 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt8; + (yyval.interm.type).setVector(3); + } +#line 6630 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 239: +#line 1780 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt8; + (yyval.interm.type).setVector(4); + } +#line 6641 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 240: +#line 1786 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt16; + (yyval.interm.type).setVector(2); + } +#line 6652 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 241: +#line 1792 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt16; + (yyval.interm.type).setVector(3); + } +#line 6663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 242: +#line 1798 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; (yyval.interm.type).setVector(4); } -#line 6611 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 238: -#line 1764 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt; - (yyval.interm.type).setVector(2); - } -#line 6622 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 239: -#line 1770 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt; - (yyval.interm.type).setVector(3); - } -#line 6633 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 240: -#line 1776 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt; - (yyval.interm.type).setVector(4); - } -#line 6644 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 241: -#line 1782 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt64; - (yyval.interm.type).setVector(2); - } -#line 6655 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 242: -#line 1788 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt64; - (yyval.interm.type).setVector(3); - } -#line 6666 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6674 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 243: -#line 1794 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1804 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).setVector(2); + } +#line 6685 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 244: +#line 1810 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).setVector(3); + } +#line 6696 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 245: +#line 1816 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).setVector(4); + } +#line 6707 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 246: +#line 1822 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt64; + (yyval.interm.type).setVector(2); + } +#line 6718 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 247: +#line 1828 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt64; + (yyval.interm.type).setVector(3); + } +#line 6729 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 248: +#line 1834 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; (yyval.interm.type).setVector(4); } -#line 6677 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 244: -#line 1800 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint; - (yyval.interm.type).setVector(2); - } -#line 6688 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 245: -#line 1806 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint; - (yyval.interm.type).setVector(3); - } -#line 6699 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 246: -#line 1812 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint; - (yyval.interm.type).setVector(4); - } -#line 6710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 247: -#line 1818 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint8; - (yyval.interm.type).setVector(2); - } -#line 6721 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 248: -#line 1824 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint8; - (yyval.interm.type).setVector(3); - } -#line 6732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6740 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 249: -#line 1830 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1840 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint; + (yyval.interm.type).setVector(2); + } +#line 6751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 250: +#line 1846 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint; + (yyval.interm.type).setVector(3); + } +#line 6762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 251: +#line 1852 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint; + (yyval.interm.type).setVector(4); + } +#line 6773 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 252: +#line 1858 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint8; + (yyval.interm.type).setVector(2); + } +#line 6784 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 253: +#line 1864 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint8; + (yyval.interm.type).setVector(3); + } +#line 6795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 254: +#line 1870 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; (yyval.interm.type).setVector(4); } -#line 6743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 250: -#line 1836 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint16; - (yyval.interm.type).setVector(2); - } -#line 6754 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 251: -#line 1842 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint16; - (yyval.interm.type).setVector(3); - } -#line 6765 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 252: -#line 1848 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint16; - (yyval.interm.type).setVector(4); - } -#line 6776 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 253: -#line 1854 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint; - (yyval.interm.type).setVector(2); - } -#line 6787 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 254: -#line 1860 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint; - (yyval.interm.type).setVector(3); - } -#line 6798 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6806 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 255: -#line 1866 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1876 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint16; + (yyval.interm.type).setVector(2); + } +#line 6817 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 256: +#line 1882 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint16; + (yyval.interm.type).setVector(3); + } +#line 6828 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 257: +#line 1888 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint16; + (yyval.interm.type).setVector(4); + } +#line 6839 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 258: +#line 1894 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint; + (yyval.interm.type).setVector(2); + } +#line 6850 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 259: +#line 1900 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint; + (yyval.interm.type).setVector(3); + } +#line 6861 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 260: +#line 1906 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(4); } -#line 6809 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 256: -#line 1872 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint64; - (yyval.interm.type).setVector(2); - } -#line 6820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 257: -#line 1878 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint64; - (yyval.interm.type).setVector(3); - } -#line 6831 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 258: -#line 1884 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint64; - (yyval.interm.type).setVector(4); - } -#line 6842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 259: -#line 1890 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 2); - } -#line 6852 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 260: -#line 1895 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(3, 3); - } -#line 6862 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 261: -#line 1900 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(4, 4); - } #line 6872 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 262: -#line 1905 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 261: +#line 1912 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { + parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 2); + (yyval.interm.type).basicType = EbtUint64; + (yyval.interm.type).setVector(2); } -#line 6882 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6883 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 262: +#line 1918 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint64; + (yyval.interm.type).setVector(3); + } +#line 6894 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 263: -#line 1910 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1924 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { + parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 3); + (yyval.interm.type).basicType = EbtUint64; + (yyval.interm.type).setVector(4); } -#line 6892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 264: -#line 1915 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 4); - } -#line 6902 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 265: -#line 1920 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(3, 2); - } -#line 6912 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 266: -#line 1925 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(3, 3); - } -#line 6922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 267: #line 1930 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(3, 4); + (yyval.interm.type).setMatrix(2, 2); } -#line 6932 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6915 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 268: + case 265: #line 1935 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(4, 2); + (yyval.interm.type).setMatrix(3, 3); } -#line 6942 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6925 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 269: + case 266: #line 1940 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(4, 3); + (yyval.interm.type).setMatrix(4, 4); } -#line 6952 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6935 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 270: + case 267: #line 1945 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(4, 4); + (yyval.interm.type).setMatrix(2, 2); } -#line 6962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 268: +#line 1950 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(2, 3); + } +#line 6955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 269: +#line 1955 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(2, 4); + } +#line 6965 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 270: +#line 1960 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(3, 2); + } +#line 6975 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 271: -#line 1950 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1965 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(2, 2); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(3, 3); } -#line 6973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6985 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 272: -#line 1956 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1970 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(3, 3); - } -#line 6984 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 273: -#line 1962 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(4, 4); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(3, 4); } #line 6995 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 274: -#line 1968 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 273: +#line 1975 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(2, 2); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(4, 2); } -#line 7006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 274: +#line 1980 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(4, 3); + } +#line 7015 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 275: -#line 1974 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1985 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(2, 3); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(4, 4); } -#line 7017 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7025 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 276: -#line 1980 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1990 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(2, 4); + (yyval.interm.type).setMatrix(2, 2); } -#line 7028 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7036 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 277: -#line 1986 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1996 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(3, 2); + (yyval.interm.type).setMatrix(3, 3); } -#line 7039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7047 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 278: -#line 1992 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2002 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(3, 3); + (yyval.interm.type).setMatrix(4, 4); } -#line 7050 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7058 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 279: -#line 1998 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2008 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(3, 4); + (yyval.interm.type).setMatrix(2, 2); } -#line 7061 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7069 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 280: -#line 2004 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2014 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(4, 2); + (yyval.interm.type).setMatrix(2, 3); } -#line 7072 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7080 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 281: -#line 2010 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2020 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(4, 3); + (yyval.interm.type).setMatrix(2, 4); } -#line 7083 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7091 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 282: -#line 2016 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2026 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setMatrix(3, 2); + } +#line 7102 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 283: +#line 2032 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setMatrix(3, 3); + } +#line 7113 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 284: +#line 2038 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setMatrix(3, 4); + } +#line 7124 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 285: +#line 2044 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setMatrix(4, 2); + } +#line 7135 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 286: +#line 2050 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setMatrix(4, 3); + } +#line 7146 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 287: +#line 2056 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 7094 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 283: -#line 2022 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(2, 2); - } -#line 7105 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 284: -#line 2028 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(3, 3); - } -#line 7116 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 285: -#line 2034 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(4, 4); - } -#line 7127 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 286: -#line 2040 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(2, 2); - } -#line 7138 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 287: -#line 2046 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(2, 3); - } -#line 7149 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7157 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 288: -#line 2052 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2062 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(2, 4); + (yyval.interm.type).setMatrix(2, 2); } -#line 7160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7168 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 289: -#line 2058 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2068 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(3, 2); + (yyval.interm.type).setMatrix(3, 3); } -#line 7171 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7179 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 290: -#line 2064 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2074 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(3, 3); + (yyval.interm.type).setMatrix(4, 4); } -#line 7182 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7190 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 291: -#line 2070 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2080 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(3, 4); + (yyval.interm.type).setMatrix(2, 2); } -#line 7193 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7201 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 292: -#line 2076 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2086 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(4, 2); + (yyval.interm.type).setMatrix(2, 3); } -#line 7204 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7212 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 293: -#line 2082 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2092 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(4, 3); + (yyval.interm.type).setMatrix(2, 4); } -#line 7215 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7223 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 294: -#line 2088 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2098 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat16; + (yyval.interm.type).setMatrix(3, 2); + } +#line 7234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 295: +#line 2104 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat16; + (yyval.interm.type).setMatrix(3, 3); + } +#line 7245 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 296: +#line 2110 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat16; + (yyval.interm.type).setMatrix(3, 4); + } +#line 7256 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 297: +#line 2116 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat16; + (yyval.interm.type).setMatrix(4, 2); + } +#line 7267 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 298: +#line 2122 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat16; + (yyval.interm.type).setMatrix(4, 3); + } +#line 7278 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 299: +#line 2128 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 4); } -#line 7226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 295: -#line 2094 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 2); - } -#line 7237 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 296: -#line 2100 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(3, 3); - } -#line 7248 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 297: -#line 2106 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(4, 4); - } -#line 7259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 298: -#line 2112 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 2); - } -#line 7270 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 299: -#line 2118 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 3); - } -#line 7281 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7289 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 300: -#line 2124 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2134 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(2, 2); + } +#line 7300 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 301: +#line 2140 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(3, 3); + } +#line 7311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 302: +#line 2146 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(4, 4); + } +#line 7322 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 303: +#line 2152 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(2, 2); + } +#line 7333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 304: +#line 2158 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(2, 3); + } +#line 7344 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 305: +#line 2164 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 4); } -#line 7292 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7355 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 301: -#line 2130 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 306: +#line 2170 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 2); } -#line 7303 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7366 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 302: -#line 2136 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 307: +#line 2176 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 7314 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7377 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 303: -#line 2142 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 308: +#line 2182 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 4); } -#line 7325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7388 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 304: -#line 2148 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 309: +#line 2188 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 2); } -#line 7336 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7399 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 305: -#line 2154 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 310: +#line 2194 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 3); } -#line 7347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7410 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 306: -#line 2160 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 311: +#line 2200 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 7358 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 307: -#line 2166 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 312: +#line 2206 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 7369 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7432 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 308: -#line 2172 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 313: +#line 2212 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 7380 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7443 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 309: -#line 2178 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 314: +#line 2218 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 7391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7454 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 310: -#line 2184 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 315: +#line 2224 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 7402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7465 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 311: -#line 2190 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 316: +#line 2230 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 3); } -#line 7413 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 312: -#line 2196 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 317: +#line 2236 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 4); } -#line 7424 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7487 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 313: -#line 2202 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 318: +#line 2242 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 2); } -#line 7435 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7498 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 314: -#line 2208 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 319: +#line 2248 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 7446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7509 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 315: -#line 2214 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 320: +#line 2254 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 4); } -#line 7457 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7520 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 316: -#line 2220 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 321: +#line 2260 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 2); } -#line 7468 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7531 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 317: -#line 2226 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 322: +#line 2266 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 3); } -#line 7479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7542 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 318: -#line 2232 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 323: +#line 2272 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 7490 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7553 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 319: -#line 2238 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 324: +#line 2278 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef NV_EXTENSIONS (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAccStructNV; #endif } -#line 7501 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7564 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 320: -#line 2244 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 325: +#line 2284 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.vulkanRemoved((yyvsp[0].lex).loc, "atomic counter types"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAtomicUint; } -#line 7511 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7574 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 321: -#line 2249 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 326: +#line 2289 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D); } -#line 7521 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 322: -#line 2254 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 327: +#line 2294 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); } -#line 7531 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7594 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 323: -#line 2259 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 328: +#line 2299 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd3D); } -#line 7541 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 324: -#line 2264 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 329: +#line 2304 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube); } -#line 7551 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7614 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 325: -#line 2269 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 330: +#line 2309 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, false, true); } -#line 7561 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7624 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 326: -#line 2274 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 331: +#line 2314 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, true); } -#line 7571 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7634 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 327: -#line 2279 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 332: +#line 2319 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, false, true); } -#line 7581 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7644 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 328: -#line 2284 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 333: +#line 2324 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true); } -#line 7591 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7654 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 329: -#line 2289 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 334: +#line 2329 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true); } -#line 7601 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7664 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 330: -#line 2294 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 335: +#line 2334 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true, true); } -#line 7611 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7674 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 331: -#line 2299 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 336: +#line 2339 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, true); } -#line 7621 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7684 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 332: -#line 2304 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 337: +#line 2344 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true); } -#line 7631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7694 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 333: -#line 2309 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 338: +#line 2349 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true, true); } -#line 7641 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 334: -#line 2314 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { -#ifdef AMD_EXTENSIONS - parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtSampler; - (yyval.interm.type).sampler.set(EbtFloat16, Esd1D); -#endif - } -#line 7654 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 335: -#line 2322 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { -#ifdef AMD_EXTENSIONS - parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtSampler; - (yyval.interm.type).sampler.set(EbtFloat16, Esd2D); -#endif - } -#line 7667 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 336: -#line 2330 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { -#ifdef AMD_EXTENSIONS - parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtSampler; - (yyval.interm.type).sampler.set(EbtFloat16, Esd3D); -#endif - } -#line 7680 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 337: -#line 2338 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { -#ifdef AMD_EXTENSIONS - parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtSampler; - (yyval.interm.type).sampler.set(EbtFloat16, EsdCube); -#endif - } -#line 7693 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 338: -#line 2346 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { -#ifdef AMD_EXTENSIONS - parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtSampler; - (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true); -#endif - } -#line 7706 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7704 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 339: @@ -7712,10 +7710,10 @@ yyreduce: parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; - (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true); + (yyval.interm.type).sampler.set(EbtFloat16, Esd1D); #endif } -#line 7719 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7717 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 340: @@ -7725,10 +7723,10 @@ yyreduce: parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; - (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true); + (yyval.interm.type).sampler.set(EbtFloat16, Esd2D); #endif } -#line 7732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7730 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 341: @@ -7738,10 +7736,10 @@ yyreduce: parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; - (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true); + (yyval.interm.type).sampler.set(EbtFloat16, Esd3D); #endif } -#line 7745 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 342: @@ -7751,10 +7749,10 @@ yyreduce: parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; - (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true); + (yyval.interm.type).sampler.set(EbtFloat16, EsdCube); #endif } -#line 7758 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7756 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 343: @@ -7764,10 +7762,10 @@ yyreduce: parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; - (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true); + (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true); #endif } -#line 7771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7769 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 344: @@ -7777,10 +7775,10 @@ yyreduce: parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; - (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true); + (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true); #endif } -#line 7784 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 345: @@ -7790,10 +7788,10 @@ yyreduce: parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; - (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true); + (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true); #endif } -#line 7797 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 346: @@ -7803,174 +7801,239 @@ yyreduce: parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; - (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true); + (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true); #endif } -#line 7810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7808 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 347: #line 2418 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { +#ifdef AMD_EXTENSIONS + parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtSampler; + (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true); +#endif + } +#line 7821 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 348: +#line 2426 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { +#ifdef AMD_EXTENSIONS + parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtSampler; + (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true); +#endif + } +#line 7834 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 349: +#line 2434 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { +#ifdef AMD_EXTENSIONS + parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtSampler; + (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true); +#endif + } +#line 7847 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 350: +#line 2442 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { +#ifdef AMD_EXTENSIONS + parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtSampler; + (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true); +#endif + } +#line 7860 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 351: +#line 2450 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { +#ifdef AMD_EXTENSIONS + parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtSampler; + (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true); +#endif + } +#line 7873 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 352: +#line 2458 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd1D); } -#line 7820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7883 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 348: -#line 2423 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 353: +#line 2463 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D); } -#line 7830 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7893 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 349: -#line 2428 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 354: +#line 2468 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd3D); } -#line 7840 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7903 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 350: -#line 2433 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 355: +#line 2473 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdCube); } -#line 7850 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 351: -#line 2438 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 356: +#line 2478 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd1D, true); } -#line 7860 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7923 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 352: -#line 2443 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 357: +#line 2483 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, true); } -#line 7870 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7933 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 353: -#line 2448 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 358: +#line 2488 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdCube, true); } -#line 7880 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7943 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 354: -#line 2453 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 359: +#line 2493 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd1D); } -#line 7890 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 355: -#line 2458 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 360: +#line 2498 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D); } -#line 7900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7963 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 356: -#line 2463 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 361: +#line 2503 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd3D); } -#line 7910 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 357: -#line 2468 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 362: +#line 2508 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdCube); } -#line 7920 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7983 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 358: -#line 2473 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 363: +#line 2513 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd1D, true); } -#line 7930 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7993 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 359: -#line 2478 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 364: +#line 2518 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, true); } -#line 7940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8003 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 360: -#line 2483 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 365: +#line 2523 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdCube, true); } -#line 7950 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8013 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 361: -#line 2488 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 366: +#line 2528 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdRect); } -#line 7960 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8023 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 362: -#line 2493 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 367: +#line 2533 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdRect, false, true); } -#line 7970 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8033 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 363: -#line 2498 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 368: +#line 2538 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7979,11 +8042,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, EsdRect); #endif } -#line 7983 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8046 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 364: -#line 2506 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 369: +#line 2546 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7992,41 +8055,41 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true); #endif } -#line 7996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8059 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 365: -#line 2514 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 370: +#line 2554 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdRect); } -#line 8006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8069 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 366: -#line 2519 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 371: +#line 2559 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdRect); } -#line 8016 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8079 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 367: -#line 2524 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 372: +#line 2564 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer); } -#line 8026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8089 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 368: -#line 2529 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 373: +#line 2569 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -8035,41 +8098,41 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer); #endif } -#line 8039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8102 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 369: -#line 2537 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 374: +#line 2577 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdBuffer); } -#line 8049 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 370: -#line 2542 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 375: +#line 2582 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdBuffer); } -#line 8059 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 371: -#line 2547 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 376: +#line 2587 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, false, true); } -#line 8069 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8132 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 372: -#line 2552 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 377: +#line 2592 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -8078,41 +8141,41 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true); #endif } -#line 8082 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8145 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 373: -#line 2560 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 378: +#line 2600 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true); } -#line 8092 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 374: -#line 2565 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 379: +#line 2605 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true); } -#line 8102 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8165 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 375: -#line 2570 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 380: +#line 2610 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true); } -#line 8112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 376: -#line 2575 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 381: +#line 2615 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -8121,61 +8184,61 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true); #endif } -#line 8125 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 377: -#line 2583 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 382: +#line 2623 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, true, false, true); } -#line 8135 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8198 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 378: -#line 2588 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 383: +#line 2628 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, true, false, true); } -#line 8145 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8208 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 379: -#line 2593 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 384: +#line 2633 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setPureSampler(false); } -#line 8155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8218 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 380: -#line 2598 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 385: +#line 2638 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setPureSampler(true); } -#line 8165 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8228 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 381: -#line 2603 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 386: +#line 2643 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D); } -#line 8175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8238 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 382: -#line 2608 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 387: +#line 2648 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8184,21 +8247,21 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D); #endif } -#line 8188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8251 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 383: -#line 2616 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 388: +#line 2656 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D); } -#line 8198 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8261 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 384: -#line 2621 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 389: +#line 2661 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8207,21 +8270,21 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D); #endif } -#line 8211 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8274 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 385: -#line 2629 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 390: +#line 2669 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D); } -#line 8221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8284 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 386: -#line 2634 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 391: +#line 2674 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8230,21 +8293,21 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D); #endif } -#line 8234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8297 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 387: -#line 2642 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 392: +#line 2682 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube); } -#line 8244 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 388: -#line 2647 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 393: +#line 2687 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8253,21 +8316,21 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube); #endif } -#line 8257 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8320 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 389: -#line 2655 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 394: +#line 2695 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D, true); } -#line 8267 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8330 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 390: -#line 2660 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 395: +#line 2700 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8276,21 +8339,21 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true); #endif } -#line 8280 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 391: -#line 2668 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 396: +#line 2708 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true); } -#line 8290 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8353 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 392: -#line 2673 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 397: +#line 2713 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8299,21 +8362,21 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true); #endif } -#line 8303 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8366 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 393: -#line 2681 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 398: +#line 2721 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube, true); } -#line 8313 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 394: -#line 2686 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 399: +#line 2726 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8322,161 +8385,161 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true); #endif } -#line 8326 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8389 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 395: -#line 2694 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 400: +#line 2734 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D); } -#line 8336 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8399 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 396: -#line 2699 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 401: +#line 2739 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D); } -#line 8346 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8409 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 397: -#line 2704 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 402: +#line 2744 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D); } -#line 8356 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 398: -#line 2709 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 403: +#line 2749 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube); } -#line 8366 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8429 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 399: -#line 2714 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 404: +#line 2754 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true); } -#line 8376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8439 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 400: -#line 2719 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 405: +#line 2759 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true); } -#line 8386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8449 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 401: -#line 2724 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 406: +#line 2764 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube, true); } -#line 8396 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8459 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 402: -#line 2729 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 407: +#line 2769 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D); } -#line 8406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8469 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 403: -#line 2734 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 408: +#line 2774 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D); } -#line 8416 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 404: -#line 2739 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 409: +#line 2779 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D); } -#line 8426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 405: -#line 2744 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 410: +#line 2784 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube); } -#line 8436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8499 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 406: -#line 2749 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 411: +#line 2789 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D, true); } -#line 8446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8509 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 407: -#line 2754 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 412: +#line 2794 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true); } -#line 8456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8519 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 408: -#line 2759 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 413: +#line 2799 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube, true); } -#line 8466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8529 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 409: -#line 2764 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 414: +#line 2804 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect); } -#line 8476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8539 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 410: -#line 2769 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 415: +#line 2809 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8485,41 +8548,41 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect); #endif } -#line 8489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8552 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 411: -#line 2777 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 416: +#line 2817 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect); } -#line 8499 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8562 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 412: -#line 2782 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 417: +#line 2822 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect); } -#line 8509 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8572 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 413: -#line 2787 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 418: +#line 2827 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer); } -#line 8519 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8582 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 414: -#line 2792 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 419: +#line 2832 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8528,41 +8591,41 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdBuffer); #endif } -#line 8532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8595 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 415: -#line 2800 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 420: +#line 2840 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer); } -#line 8542 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8605 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 416: -#line 2805 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 421: +#line 2845 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer); } -#line 8552 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8615 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 417: -#line 2810 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 422: +#line 2850 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, false, false, true); } -#line 8562 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8625 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 418: -#line 2815 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 423: +#line 2855 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8571,41 +8634,41 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true); #endif } -#line 8575 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 419: -#line 2823 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 424: +#line 2863 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, false, false, true); } -#line 8585 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 420: -#line 2828 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 425: +#line 2868 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, false, false, true); } -#line 8595 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8658 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 421: -#line 2833 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 426: +#line 2873 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true, false, true); } -#line 8605 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 422: -#line 2838 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 427: +#line 2878 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8614,41 +8677,41 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true); #endif } -#line 8618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 423: -#line 2846 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 428: +#line 2886 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true, false, true); } -#line 8628 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 424: -#line 2851 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 429: +#line 2891 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true, false, true); } -#line 8638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8701 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 425: -#line 2856 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 430: +#line 2896 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D); } -#line 8648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 426: -#line 2861 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 431: +#line 2901 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8657,41 +8720,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D); #endif } -#line 8661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8724 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 427: -#line 2869 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 432: +#line 2909 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd1D); } -#line 8671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8734 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 428: -#line 2874 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 433: +#line 2914 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd1D); } -#line 8681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8744 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 429: -#line 2879 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 434: +#line 2919 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D); } -#line 8691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8754 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 430: -#line 2884 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 435: +#line 2924 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8700,41 +8763,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D); #endif } -#line 8704 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8767 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 431: -#line 2892 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 436: +#line 2932 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D); } -#line 8714 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8777 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 432: -#line 2897 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 437: +#line 2937 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D); } -#line 8724 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8787 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 433: -#line 2902 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 438: +#line 2942 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D); } -#line 8734 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8797 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 434: -#line 2907 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 439: +#line 2947 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8743,41 +8806,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D); #endif } -#line 8747 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 435: -#line 2915 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 440: +#line 2955 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd3D); } -#line 8757 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 436: -#line 2920 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 441: +#line 2960 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd3D); } -#line 8767 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8830 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 437: -#line 2925 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 442: +#line 2965 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect); } -#line 8777 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8840 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 438: -#line 2930 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 443: +#line 2970 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8786,41 +8849,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect); #endif } -#line 8790 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 439: -#line 2938 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 444: +#line 2978 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdRect); } -#line 8800 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 440: -#line 2943 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 445: +#line 2983 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdRect); } -#line 8810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8873 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 441: -#line 2948 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 446: +#line 2988 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube); } -#line 8820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8883 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 442: -#line 2953 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 447: +#line 2993 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8829,41 +8892,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube); #endif } -#line 8833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8896 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 443: -#line 2961 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 448: +#line 3001 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdCube); } -#line 8843 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8906 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 444: -#line 2966 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 449: +#line 3006 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdCube); } -#line 8853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8916 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 445: -#line 2971 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 450: +#line 3011 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer); } -#line 8863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8926 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 446: -#line 2976 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 451: +#line 3016 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8872,41 +8935,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer); #endif } -#line 8876 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8939 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 447: -#line 2984 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 452: +#line 3024 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer); } -#line 8886 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 448: -#line 2989 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 453: +#line 3029 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer); } -#line 8896 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8959 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 449: -#line 2994 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 454: +#line 3034 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D, true); } -#line 8906 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8969 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 450: -#line 2999 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 455: +#line 3039 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8915,41 +8978,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true); #endif } -#line 8919 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8982 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 451: -#line 3007 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 456: +#line 3047 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd1D, true); } -#line 8929 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8992 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 452: -#line 3012 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 457: +#line 3052 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd1D, true); } -#line 8939 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9002 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 453: -#line 3017 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 458: +#line 3057 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true); } -#line 8949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9012 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 454: -#line 3022 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 459: +#line 3062 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8958,41 +9021,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true); #endif } -#line 8962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9025 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 455: -#line 3030 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 460: +#line 3070 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true); } -#line 8972 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 456: -#line 3035 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 461: +#line 3075 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true); } -#line 8982 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9045 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 457: -#line 3040 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 462: +#line 3080 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube, true); } -#line 8992 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9055 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 458: -#line 3045 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 463: +#line 3085 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -9001,41 +9064,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true); #endif } -#line 9005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9068 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 459: -#line 3053 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 464: +#line 3093 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdCube, true); } -#line 9015 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9078 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 460: -#line 3058 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 465: +#line 3098 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdCube, true); } -#line 9025 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9088 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 461: -#line 3063 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 466: +#line 3103 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, false, false, true); } -#line 9035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9098 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 462: -#line 3068 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 467: +#line 3108 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -9044,41 +9107,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true); #endif } -#line 9048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 463: -#line 3076 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 468: +#line 3116 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, false, false, true); } -#line 9058 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9121 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 464: -#line 3081 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 469: +#line 3121 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, false, false, true); } -#line 9068 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 465: -#line 3086 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 470: +#line 3126 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true, false, true); } -#line 9078 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 466: -#line 3091 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 471: +#line 3131 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -9087,75 +9150,75 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true); #endif } -#line 9091 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9154 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 467: -#line 3099 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 472: +#line 3139 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true, false, true); } -#line 9101 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9164 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 468: -#line 3104 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 473: +#line 3144 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true, false, true); } -#line 9111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9174 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 469: -#line 3109 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 474: +#line 3149 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // GL_OES_EGL_image_external (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); (yyval.interm.type).sampler.external = true; } -#line 9122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9185 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 470: -#line 3115 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 475: +#line 3155 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // GL_EXT_YUV_target (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); (yyval.interm.type).sampler.yuv = true; } -#line 9133 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9196 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 471: -#line 3121 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 476: +#line 3161 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat); } -#line 9144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9207 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 472: -#line 3127 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 477: +#line 3167 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat, true); } -#line 9155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9218 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 473: -#line 3133 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 478: +#line 3173 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); @@ -9165,11 +9228,11 @@ yyreduce: (yyval.interm.type).sampler.setSubpass(EbtFloat16); #endif } -#line 9169 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9232 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 474: -#line 3142 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 479: +#line 3182 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); @@ -9179,65 +9242,76 @@ yyreduce: (yyval.interm.type).sampler.setSubpass(EbtFloat16, true); #endif } -#line 9183 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 475: -#line 3151 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 480: +#line 3191 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtInt); } -#line 9194 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9257 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 476: -#line 3157 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 481: +#line 3197 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtInt, true); } -#line 9205 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9268 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 477: -#line 3163 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 482: +#line 3203 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtUint); } -#line 9216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9279 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 478: -#line 3169 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 483: +#line 3209 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtUint, true); } -#line 9227 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9290 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 479: -#line 3175 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 484: +#line 3215 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.fcoopmatCheck((yyvsp[0].lex).loc, "fcoopmatNV", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).coopmat = true; + } +#line 9301 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 485: +#line 3221 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary; parseContext.structTypeCheck((yyval.interm.type).loc, (yyval.interm.type)); } -#line 9237 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 480: -#line 3180 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 486: +#line 3226 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // // This is for user defined type names. The lexical phase looked up the @@ -9251,47 +9325,47 @@ yyreduce: } else parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), ""); } -#line 9255 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9329 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 481: -#line 3196 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 487: +#line 3242 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "highp precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqHigh); } -#line 9265 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9339 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 482: -#line 3201 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 488: +#line 3247 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqMedium); } -#line 9275 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9349 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 483: -#line 3206 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 489: +#line 3252 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqLow); } -#line 9285 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9359 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 484: -#line 3214 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 490: +#line 3260 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); } -#line 9291 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 485: -#line 3214 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 491: +#line 3260 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string); parseContext.structArrayCheck((yyvsp[-4].lex).loc, *structure); @@ -9303,17 +9377,17 @@ yyreduce: (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 9307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 486: -#line 3225 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 492: +#line 3271 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); } -#line 9313 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9387 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 487: -#line 3225 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 493: +#line 3271 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { TType* structure = new TType((yyvsp[-1].interm.typeList), TString("")); (yyval.interm.type).init((yyvsp[-4].lex).loc); @@ -9321,19 +9395,19 @@ yyreduce: (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 9325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9399 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 488: -#line 3235 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 494: +#line 3281 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList) = (yyvsp[0].interm.typeList); } -#line 9333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9407 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 489: -#line 3238 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 495: +#line 3284 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) { @@ -9344,11 +9418,11 @@ yyreduce: (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]); } } -#line 9348 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9422 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 490: -#line 3251 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 496: +#line 3297 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -9371,11 +9445,11 @@ yyreduce: (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 9375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9449 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 491: -#line 3273 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 497: +#line 3319 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -9400,38 +9474,38 @@ yyreduce: (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 9404 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9478 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 492: -#line 3300 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 498: +#line 3346 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList) = new TTypeList; (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 9413 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9487 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 493: -#line 3304 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 499: +#line 3350 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 9421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9495 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 494: -#line 3310 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 500: +#line 3356 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeLine).type = new TType(EbtVoid); (yyval.interm.typeLine).loc = (yyvsp[0].lex).loc; (yyval.interm.typeLine).type->setFieldName(*(yyvsp[0].lex).string); } -#line 9431 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 495: -#line 3315 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 501: +#line 3361 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes); @@ -9440,219 +9514,219 @@ yyreduce: (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string); (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes); } -#line 9444 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9518 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 496: -#line 3326 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 502: +#line 3372 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 9452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 497: -#line 3329 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 503: +#line 3375 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { const char* initFeature = "{ } style initializers"; parseContext.requireProfile((yyvsp[-2].lex).loc, ~EEsProfile, initFeature); parseContext.profileRequires((yyvsp[-2].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); } -#line 9463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 498: -#line 3335 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 504: +#line 3381 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { const char* initFeature = "{ } style initializers"; parseContext.requireProfile((yyvsp[-3].lex).loc, ~EEsProfile, initFeature); parseContext.profileRequires((yyvsp[-3].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 9474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 499: -#line 3344 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc()); - } -#line 9482 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 500: -#line 3347 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); - } -#line 9490 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 501: -#line 3353 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 502: -#line 3357 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9502 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 503: -#line 3358 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9508 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 504: -#line 3364 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9514 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9548 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 505: -#line 3365 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9520 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 506: -#line 3366 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 507: -#line 3367 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 508: -#line 3368 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9538 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 509: -#line 3369 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9544 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 510: -#line 3370 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9550 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 511: -#line 3374 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = 0; } +#line 3390 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc()); + } #line 9556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; + case 506: +#line 3393 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); + } +#line 9564 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 507: +#line 3399 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9570 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 508: +#line 3403 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 509: +#line 3404 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9582 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 510: +#line 3410 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9588 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 511: +#line 3411 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9594 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + case 512: -#line 3375 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3412 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 513: +#line 3413 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 514: +#line 3414 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9612 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 515: +#line 3415 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 516: +#line 3416 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9624 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 517: +#line 3420 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = 0; } +#line 9630 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 518: +#line 3421 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; } -#line 9565 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9639 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 513: -#line 3379 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 519: +#line 3425 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; } -#line 9574 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 514: -#line 3383 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 520: +#line 3429 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate()) (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode); } -#line 9584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9658 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 515: -#line 3391 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 521: +#line 3437 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9590 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9664 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 516: -#line 3392 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 522: +#line 3438 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9670 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 517: -#line 3396 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 523: +#line 3442 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { ++parseContext.controlFlowNestingLevel; } -#line 9604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 518: -#line 3399 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 524: +#line 3445 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9613 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9687 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 519: -#line 3403 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 525: +#line 3449 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 9623 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 520: -#line 3408 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 526: +#line 3454 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9634 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9708 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 521: -#line 3417 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 527: +#line 3463 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; } -#line 9642 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9716 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 522: -#line 3420 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 528: +#line 3466 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate()) (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode); } -#line 9652 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9726 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 523: -#line 3428 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 529: +#line 3474 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || @@ -9661,11 +9735,11 @@ yyreduce: (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case } } -#line 9665 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9739 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 524: -#line 3436 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 530: +#line 3482 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) { @@ -9674,76 +9748,76 @@ yyreduce: } else (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 9678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9752 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 525: -#line 3447 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 531: +#line 3493 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; } -#line 9684 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9758 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 526: -#line 3448 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 532: +#line 3494 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = static_cast((yyvsp[-1].interm.intermTypedNode)); } -#line 9690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9764 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 527: -#line 3452 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 533: +#line 3498 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9698 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 528: -#line 3455 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 534: +#line 3501 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9707 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9781 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 529: -#line 3461 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 535: +#line 3507 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-2].interm.intermTypedNode)); (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yyvsp[-4].lex).loc); } -#line 9716 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9790 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 530: -#line 3468 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 536: +#line 3514 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode); } -#line 9725 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9799 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 531: -#line 3472 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 537: +#line 3518 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode); (yyval.interm.nodePair).node2 = 0; } -#line 9734 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9808 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 532: -#line 3480 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 538: +#line 3526 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)); } -#line 9743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9817 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 533: -#line 3484 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 539: +#line 3530 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type)); @@ -9754,28 +9828,28 @@ yyreduce: else (yyval.interm.intermTypedNode) = 0; } -#line 9758 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9832 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 534: -#line 3497 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 540: +#line 3543 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9766 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9840 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 535: -#line 3500 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 541: +#line 3546 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9775 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9849 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 536: -#line 3506 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 542: +#line 3552 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // start new switch sequence on the switch stack ++parseContext.controlFlowNestingLevel; @@ -9784,11 +9858,11 @@ yyreduce: parseContext.switchLevel.push_back(parseContext.statementNestingLevel); parseContext.symbolTable.push(); } -#line 9788 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9862 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 537: -#line 3514 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 543: +#line 3560 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[-7].lex).loc, (yyvsp[-5].interm.intermTypedNode), (yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0); delete parseContext.switchSequenceStack.back(); @@ -9798,27 +9872,27 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 9802 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9876 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 538: -#line 3526 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 544: +#line 3572 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; } -#line 9810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9884 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 539: -#line 3529 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 545: +#line 3575 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9818 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 540: -#line 3535 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 546: +#line 3581 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -9831,11 +9905,11 @@ yyreduce: (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc); } } -#line 9835 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9909 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 541: -#line 3547 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 547: +#line 3593 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -9845,28 +9919,28 @@ yyreduce: else (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc); } -#line 9849 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9923 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 542: -#line 3559 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 548: +#line 3605 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9857 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9931 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 543: -#line 3562 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 549: +#line 3608 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9866 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 544: -#line 3568 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 550: +#line 3614 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", ""); @@ -9875,11 +9949,11 @@ yyreduce: ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 9879 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 545: -#line 3576 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 551: +#line 3622 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, true, (yyvsp[-5].lex).loc); @@ -9887,21 +9961,21 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 9891 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9965 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 546: -#line 3583 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 552: +#line 3629 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 9901 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9975 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 547: -#line 3588 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 553: +#line 3634 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", ""); @@ -9913,22 +9987,22 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 9917 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9991 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 548: -#line 3599 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 554: +#line 3645 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.push(); ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 9928 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10002 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 549: -#line 3605 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 555: +#line 3651 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc); @@ -9941,81 +10015,81 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 9945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10019 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 550: -#line 3620 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 556: +#line 3666 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10027 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 551: -#line 3623 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 557: +#line 3669 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9961 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 552: -#line 3629 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 558: +#line 3675 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 9969 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10043 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 553: -#line 3632 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 559: +#line 3678 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = 0; } -#line 9977 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10051 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 554: -#line 3638 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 560: +#line 3684 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode); (yyval.interm.nodePair).node2 = 0; } -#line 9986 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10060 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 555: -#line 3642 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 561: +#line 3688 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode); } -#line 9995 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10069 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 556: -#line 3649 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 562: +#line 3695 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if (parseContext.loopNestingLevel <= 0) parseContext.error((yyvsp[-1].lex).loc, "continue statement only allowed in loops", "", ""); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpContinue, (yyvsp[-1].lex).loc); } -#line 10005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10079 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 557: -#line 3654 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 563: +#line 3700 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0) parseContext.error((yyvsp[-1].lex).loc, "break statement only allowed in switch and loops", "", ""); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpBreak, (yyvsp[-1].lex).loc); } -#line 10015 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10089 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 558: -#line 3659 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 564: +#line 3705 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc); if (parseContext.currentFunctionType->getBasicType() != EbtVoid) @@ -10023,83 +10097,83 @@ yyreduce: if (parseContext.inMain) parseContext.postEntryPointReturn = true; } -#line 10027 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10101 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 559: -#line 3666 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 565: +#line 3712 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode)); } -#line 10035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10109 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 560: -#line 3669 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 566: +#line 3715 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc); } -#line 10044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10118 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 561: -#line 3678 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 567: +#line 3724 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } -#line 10053 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10127 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 562: -#line 3682 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 568: +#line 3728 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[0].interm.intermNode) != nullptr) { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } } -#line 10064 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10138 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 563: -#line 3691 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 569: +#line 3737 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 10072 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10146 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 564: -#line 3694 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 570: +#line 3740 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 10080 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10154 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 565: -#line 3697 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 571: +#line 3743 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "extraneous semicolon"); parseContext.profileRequires((yyvsp[0].lex).loc, ~EEsProfile, 460, nullptr, "extraneous semicolon"); (yyval.interm.intermNode) = nullptr; } -#line 10090 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10164 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 566: -#line 3705 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 572: +#line 3751 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyvsp[0].interm).function = parseContext.handleFunctionDeclarator((yyvsp[0].interm).loc, *(yyvsp[0].interm).function, false /* not prototype */); (yyvsp[0].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[0].interm).loc, *(yyvsp[0].interm).function); } -#line 10099 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10173 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 567: -#line 3709 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 573: +#line 3755 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // May be best done as post process phase on intermediate code if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue) @@ -10115,52 +10189,52 @@ yyreduce: (yyval.interm.intermNode)->getAsAggregate()->setDebug(parseContext.contextPragma.debug); (yyval.interm.intermNode)->getAsAggregate()->setPragmaTable(parseContext.contextPragma.pragmaTable); } -#line 10119 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10193 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 568: -#line 3727 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 574: +#line 3773 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.attributes) = (yyvsp[-2].interm.attributes); parseContext.requireExtensions((yyvsp[-4].lex).loc, 1, &E_GL_EXT_control_flow_attributes, "attribute"); } -#line 10128 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 569: -#line 3733 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 575: +#line 3779 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.attributes) = (yyvsp[0].interm.attributes); } -#line 10136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10210 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 570: -#line 3736 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 576: +#line 3782 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes)); } -#line 10144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10218 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 571: -#line 3741 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 577: +#line 3787 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string); } -#line 10152 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 572: -#line 3744 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 578: +#line 3790 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode)); } -#line 10160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; -#line 10164 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10238 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -10388,5 +10462,5 @@ yyreturn: #endif return yyresult; } -#line 3748 "MachineIndependent/glslang.y" /* yacc.c:1906 */ +#line 3794 "MachineIndependent/glslang.y" /* yacc.c:1906 */ diff --git a/glslang/MachineIndependent/glslang_tab.cpp.h b/glslang/MachineIndependent/glslang_tab.cpp.h index 6fcdd926..a467db64 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp.h +++ b/glslang/MachineIndependent/glslang_tab.cpp.h @@ -220,235 +220,236 @@ extern int yydebug; F64MAT4X4 = 430, ATOMIC_UINT = 431, ACCSTRUCTNV = 432, - SAMPLER1D = 433, - SAMPLER2D = 434, - SAMPLER3D = 435, - SAMPLERCUBE = 436, - SAMPLER1DSHADOW = 437, - SAMPLER2DSHADOW = 438, - SAMPLERCUBESHADOW = 439, - SAMPLER1DARRAY = 440, - SAMPLER2DARRAY = 441, - SAMPLER1DARRAYSHADOW = 442, - SAMPLER2DARRAYSHADOW = 443, - ISAMPLER1D = 444, - ISAMPLER2D = 445, - ISAMPLER3D = 446, - ISAMPLERCUBE = 447, - ISAMPLER1DARRAY = 448, - ISAMPLER2DARRAY = 449, - USAMPLER1D = 450, - USAMPLER2D = 451, - USAMPLER3D = 452, - USAMPLERCUBE = 453, - USAMPLER1DARRAY = 454, - USAMPLER2DARRAY = 455, - SAMPLER2DRECT = 456, - SAMPLER2DRECTSHADOW = 457, - ISAMPLER2DRECT = 458, - USAMPLER2DRECT = 459, - SAMPLERBUFFER = 460, - ISAMPLERBUFFER = 461, - USAMPLERBUFFER = 462, - SAMPLERCUBEARRAY = 463, - SAMPLERCUBEARRAYSHADOW = 464, - ISAMPLERCUBEARRAY = 465, - USAMPLERCUBEARRAY = 466, - SAMPLER2DMS = 467, - ISAMPLER2DMS = 468, - USAMPLER2DMS = 469, - SAMPLER2DMSARRAY = 470, - ISAMPLER2DMSARRAY = 471, - USAMPLER2DMSARRAY = 472, - SAMPLEREXTERNALOES = 473, - SAMPLEREXTERNAL2DY2YEXT = 474, - F16SAMPLER1D = 475, - F16SAMPLER2D = 476, - F16SAMPLER3D = 477, - F16SAMPLER2DRECT = 478, - F16SAMPLERCUBE = 479, - F16SAMPLER1DARRAY = 480, - F16SAMPLER2DARRAY = 481, - F16SAMPLERCUBEARRAY = 482, - F16SAMPLERBUFFER = 483, - F16SAMPLER2DMS = 484, - F16SAMPLER2DMSARRAY = 485, - F16SAMPLER1DSHADOW = 486, - F16SAMPLER2DSHADOW = 487, - F16SAMPLER1DARRAYSHADOW = 488, - F16SAMPLER2DARRAYSHADOW = 489, - F16SAMPLER2DRECTSHADOW = 490, - F16SAMPLERCUBESHADOW = 491, - F16SAMPLERCUBEARRAYSHADOW = 492, - SAMPLER = 493, - SAMPLERSHADOW = 494, - TEXTURE1D = 495, - TEXTURE2D = 496, - TEXTURE3D = 497, - TEXTURECUBE = 498, - TEXTURE1DARRAY = 499, - TEXTURE2DARRAY = 500, - ITEXTURE1D = 501, - ITEXTURE2D = 502, - ITEXTURE3D = 503, - ITEXTURECUBE = 504, - ITEXTURE1DARRAY = 505, - ITEXTURE2DARRAY = 506, - UTEXTURE1D = 507, - UTEXTURE2D = 508, - UTEXTURE3D = 509, - UTEXTURECUBE = 510, - UTEXTURE1DARRAY = 511, - UTEXTURE2DARRAY = 512, - TEXTURE2DRECT = 513, - ITEXTURE2DRECT = 514, - UTEXTURE2DRECT = 515, - TEXTUREBUFFER = 516, - ITEXTUREBUFFER = 517, - UTEXTUREBUFFER = 518, - TEXTURECUBEARRAY = 519, - ITEXTURECUBEARRAY = 520, - UTEXTURECUBEARRAY = 521, - TEXTURE2DMS = 522, - ITEXTURE2DMS = 523, - UTEXTURE2DMS = 524, - TEXTURE2DMSARRAY = 525, - ITEXTURE2DMSARRAY = 526, - UTEXTURE2DMSARRAY = 527, - F16TEXTURE1D = 528, - F16TEXTURE2D = 529, - F16TEXTURE3D = 530, - F16TEXTURE2DRECT = 531, - F16TEXTURECUBE = 532, - F16TEXTURE1DARRAY = 533, - F16TEXTURE2DARRAY = 534, - F16TEXTURECUBEARRAY = 535, - F16TEXTUREBUFFER = 536, - F16TEXTURE2DMS = 537, - F16TEXTURE2DMSARRAY = 538, - SUBPASSINPUT = 539, - SUBPASSINPUTMS = 540, - ISUBPASSINPUT = 541, - ISUBPASSINPUTMS = 542, - USUBPASSINPUT = 543, - USUBPASSINPUTMS = 544, - F16SUBPASSINPUT = 545, - F16SUBPASSINPUTMS = 546, - IMAGE1D = 547, - IIMAGE1D = 548, - UIMAGE1D = 549, - IMAGE2D = 550, - IIMAGE2D = 551, - UIMAGE2D = 552, - IMAGE3D = 553, - IIMAGE3D = 554, - UIMAGE3D = 555, - IMAGE2DRECT = 556, - IIMAGE2DRECT = 557, - UIMAGE2DRECT = 558, - IMAGECUBE = 559, - IIMAGECUBE = 560, - UIMAGECUBE = 561, - IMAGEBUFFER = 562, - IIMAGEBUFFER = 563, - UIMAGEBUFFER = 564, - IMAGE1DARRAY = 565, - IIMAGE1DARRAY = 566, - UIMAGE1DARRAY = 567, - IMAGE2DARRAY = 568, - IIMAGE2DARRAY = 569, - UIMAGE2DARRAY = 570, - IMAGECUBEARRAY = 571, - IIMAGECUBEARRAY = 572, - UIMAGECUBEARRAY = 573, - IMAGE2DMS = 574, - IIMAGE2DMS = 575, - UIMAGE2DMS = 576, - IMAGE2DMSARRAY = 577, - IIMAGE2DMSARRAY = 578, - UIMAGE2DMSARRAY = 579, - F16IMAGE1D = 580, - F16IMAGE2D = 581, - F16IMAGE3D = 582, - F16IMAGE2DRECT = 583, - F16IMAGECUBE = 584, - F16IMAGE1DARRAY = 585, - F16IMAGE2DARRAY = 586, - F16IMAGECUBEARRAY = 587, - F16IMAGEBUFFER = 588, - F16IMAGE2DMS = 589, - F16IMAGE2DMSARRAY = 590, - STRUCT = 591, - VOID = 592, - WHILE = 593, - IDENTIFIER = 594, - TYPE_NAME = 595, - FLOATCONSTANT = 596, - DOUBLECONSTANT = 597, - INT16CONSTANT = 598, - UINT16CONSTANT = 599, - INT32CONSTANT = 600, - UINT32CONSTANT = 601, - INTCONSTANT = 602, - UINTCONSTANT = 603, - INT64CONSTANT = 604, - UINT64CONSTANT = 605, - BOOLCONSTANT = 606, - FLOAT16CONSTANT = 607, - LEFT_OP = 608, - RIGHT_OP = 609, - INC_OP = 610, - DEC_OP = 611, - LE_OP = 612, - GE_OP = 613, - EQ_OP = 614, - NE_OP = 615, - AND_OP = 616, - OR_OP = 617, - XOR_OP = 618, - MUL_ASSIGN = 619, - DIV_ASSIGN = 620, - ADD_ASSIGN = 621, - MOD_ASSIGN = 622, - LEFT_ASSIGN = 623, - RIGHT_ASSIGN = 624, - AND_ASSIGN = 625, - XOR_ASSIGN = 626, - OR_ASSIGN = 627, - SUB_ASSIGN = 628, - LEFT_PAREN = 629, - RIGHT_PAREN = 630, - LEFT_BRACKET = 631, - RIGHT_BRACKET = 632, - LEFT_BRACE = 633, - RIGHT_BRACE = 634, - DOT = 635, - COMMA = 636, - COLON = 637, - EQUAL = 638, - SEMICOLON = 639, - BANG = 640, - DASH = 641, - TILDE = 642, - PLUS = 643, - STAR = 644, - SLASH = 645, - PERCENT = 646, - LEFT_ANGLE = 647, - RIGHT_ANGLE = 648, - VERTICAL_BAR = 649, - CARET = 650, - AMPERSAND = 651, - QUESTION = 652, - INVARIANT = 653, - PRECISE = 654, - HIGH_PRECISION = 655, - MEDIUM_PRECISION = 656, - LOW_PRECISION = 657, - PRECISION = 658, - PACKED = 659, - RESOURCE = 660, - SUPERP = 661 + FCOOPMATNV = 433, + SAMPLER1D = 434, + SAMPLER2D = 435, + SAMPLER3D = 436, + SAMPLERCUBE = 437, + SAMPLER1DSHADOW = 438, + SAMPLER2DSHADOW = 439, + SAMPLERCUBESHADOW = 440, + SAMPLER1DARRAY = 441, + SAMPLER2DARRAY = 442, + SAMPLER1DARRAYSHADOW = 443, + SAMPLER2DARRAYSHADOW = 444, + ISAMPLER1D = 445, + ISAMPLER2D = 446, + ISAMPLER3D = 447, + ISAMPLERCUBE = 448, + ISAMPLER1DARRAY = 449, + ISAMPLER2DARRAY = 450, + USAMPLER1D = 451, + USAMPLER2D = 452, + USAMPLER3D = 453, + USAMPLERCUBE = 454, + USAMPLER1DARRAY = 455, + USAMPLER2DARRAY = 456, + SAMPLER2DRECT = 457, + SAMPLER2DRECTSHADOW = 458, + ISAMPLER2DRECT = 459, + USAMPLER2DRECT = 460, + SAMPLERBUFFER = 461, + ISAMPLERBUFFER = 462, + USAMPLERBUFFER = 463, + SAMPLERCUBEARRAY = 464, + SAMPLERCUBEARRAYSHADOW = 465, + ISAMPLERCUBEARRAY = 466, + USAMPLERCUBEARRAY = 467, + SAMPLER2DMS = 468, + ISAMPLER2DMS = 469, + USAMPLER2DMS = 470, + SAMPLER2DMSARRAY = 471, + ISAMPLER2DMSARRAY = 472, + USAMPLER2DMSARRAY = 473, + SAMPLEREXTERNALOES = 474, + SAMPLEREXTERNAL2DY2YEXT = 475, + F16SAMPLER1D = 476, + F16SAMPLER2D = 477, + F16SAMPLER3D = 478, + F16SAMPLER2DRECT = 479, + F16SAMPLERCUBE = 480, + F16SAMPLER1DARRAY = 481, + F16SAMPLER2DARRAY = 482, + F16SAMPLERCUBEARRAY = 483, + F16SAMPLERBUFFER = 484, + F16SAMPLER2DMS = 485, + F16SAMPLER2DMSARRAY = 486, + F16SAMPLER1DSHADOW = 487, + F16SAMPLER2DSHADOW = 488, + F16SAMPLER1DARRAYSHADOW = 489, + F16SAMPLER2DARRAYSHADOW = 490, + F16SAMPLER2DRECTSHADOW = 491, + F16SAMPLERCUBESHADOW = 492, + F16SAMPLERCUBEARRAYSHADOW = 493, + SAMPLER = 494, + SAMPLERSHADOW = 495, + TEXTURE1D = 496, + TEXTURE2D = 497, + TEXTURE3D = 498, + TEXTURECUBE = 499, + TEXTURE1DARRAY = 500, + TEXTURE2DARRAY = 501, + ITEXTURE1D = 502, + ITEXTURE2D = 503, + ITEXTURE3D = 504, + ITEXTURECUBE = 505, + ITEXTURE1DARRAY = 506, + ITEXTURE2DARRAY = 507, + UTEXTURE1D = 508, + UTEXTURE2D = 509, + UTEXTURE3D = 510, + UTEXTURECUBE = 511, + UTEXTURE1DARRAY = 512, + UTEXTURE2DARRAY = 513, + TEXTURE2DRECT = 514, + ITEXTURE2DRECT = 515, + UTEXTURE2DRECT = 516, + TEXTUREBUFFER = 517, + ITEXTUREBUFFER = 518, + UTEXTUREBUFFER = 519, + TEXTURECUBEARRAY = 520, + ITEXTURECUBEARRAY = 521, + UTEXTURECUBEARRAY = 522, + TEXTURE2DMS = 523, + ITEXTURE2DMS = 524, + UTEXTURE2DMS = 525, + TEXTURE2DMSARRAY = 526, + ITEXTURE2DMSARRAY = 527, + UTEXTURE2DMSARRAY = 528, + F16TEXTURE1D = 529, + F16TEXTURE2D = 530, + F16TEXTURE3D = 531, + F16TEXTURE2DRECT = 532, + F16TEXTURECUBE = 533, + F16TEXTURE1DARRAY = 534, + F16TEXTURE2DARRAY = 535, + F16TEXTURECUBEARRAY = 536, + F16TEXTUREBUFFER = 537, + F16TEXTURE2DMS = 538, + F16TEXTURE2DMSARRAY = 539, + SUBPASSINPUT = 540, + SUBPASSINPUTMS = 541, + ISUBPASSINPUT = 542, + ISUBPASSINPUTMS = 543, + USUBPASSINPUT = 544, + USUBPASSINPUTMS = 545, + F16SUBPASSINPUT = 546, + F16SUBPASSINPUTMS = 547, + IMAGE1D = 548, + IIMAGE1D = 549, + UIMAGE1D = 550, + IMAGE2D = 551, + IIMAGE2D = 552, + UIMAGE2D = 553, + IMAGE3D = 554, + IIMAGE3D = 555, + UIMAGE3D = 556, + IMAGE2DRECT = 557, + IIMAGE2DRECT = 558, + UIMAGE2DRECT = 559, + IMAGECUBE = 560, + IIMAGECUBE = 561, + UIMAGECUBE = 562, + IMAGEBUFFER = 563, + IIMAGEBUFFER = 564, + UIMAGEBUFFER = 565, + IMAGE1DARRAY = 566, + IIMAGE1DARRAY = 567, + UIMAGE1DARRAY = 568, + IMAGE2DARRAY = 569, + IIMAGE2DARRAY = 570, + UIMAGE2DARRAY = 571, + IMAGECUBEARRAY = 572, + IIMAGECUBEARRAY = 573, + UIMAGECUBEARRAY = 574, + IMAGE2DMS = 575, + IIMAGE2DMS = 576, + UIMAGE2DMS = 577, + IMAGE2DMSARRAY = 578, + IIMAGE2DMSARRAY = 579, + UIMAGE2DMSARRAY = 580, + F16IMAGE1D = 581, + F16IMAGE2D = 582, + F16IMAGE3D = 583, + F16IMAGE2DRECT = 584, + F16IMAGECUBE = 585, + F16IMAGE1DARRAY = 586, + F16IMAGE2DARRAY = 587, + F16IMAGECUBEARRAY = 588, + F16IMAGEBUFFER = 589, + F16IMAGE2DMS = 590, + F16IMAGE2DMSARRAY = 591, + STRUCT = 592, + VOID = 593, + WHILE = 594, + IDENTIFIER = 595, + TYPE_NAME = 596, + FLOATCONSTANT = 597, + DOUBLECONSTANT = 598, + INT16CONSTANT = 599, + UINT16CONSTANT = 600, + INT32CONSTANT = 601, + UINT32CONSTANT = 602, + INTCONSTANT = 603, + UINTCONSTANT = 604, + INT64CONSTANT = 605, + UINT64CONSTANT = 606, + BOOLCONSTANT = 607, + FLOAT16CONSTANT = 608, + LEFT_OP = 609, + RIGHT_OP = 610, + INC_OP = 611, + DEC_OP = 612, + LE_OP = 613, + GE_OP = 614, + EQ_OP = 615, + NE_OP = 616, + AND_OP = 617, + OR_OP = 618, + XOR_OP = 619, + MUL_ASSIGN = 620, + DIV_ASSIGN = 621, + ADD_ASSIGN = 622, + MOD_ASSIGN = 623, + LEFT_ASSIGN = 624, + RIGHT_ASSIGN = 625, + AND_ASSIGN = 626, + XOR_ASSIGN = 627, + OR_ASSIGN = 628, + SUB_ASSIGN = 629, + LEFT_PAREN = 630, + RIGHT_PAREN = 631, + LEFT_BRACKET = 632, + RIGHT_BRACKET = 633, + LEFT_BRACE = 634, + RIGHT_BRACE = 635, + DOT = 636, + COMMA = 637, + COLON = 638, + EQUAL = 639, + SEMICOLON = 640, + BANG = 641, + DASH = 642, + TILDE = 643, + PLUS = 644, + STAR = 645, + SLASH = 646, + PERCENT = 647, + LEFT_ANGLE = 648, + RIGHT_ANGLE = 649, + VERTICAL_BAR = 650, + CARET = 651, + AMPERSAND = 652, + QUESTION = 653, + INVARIANT = 654, + PRECISE = 655, + HIGH_PRECISION = 656, + MEDIUM_PRECISION = 657, + LOW_PRECISION = 658, + PRECISION = 659, + PACKED = 660, + RESOURCE = 661, + SUPERP = 662 }; #endif @@ -490,9 +491,10 @@ union YYSTYPE glslang::TArraySizes* arraySizes; glslang::TIdentifierList* identifierList; }; + glslang::TArraySizes* typeParameters; } interm; -#line 496 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909 */ +#line 498 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909 */ }; typedef union YYSTYPE YYSTYPE; diff --git a/glslang/MachineIndependent/intermOut.cpp b/glslang/MachineIndependent/intermOut.cpp index f74b90aa..f04981e3 100644 --- a/glslang/MachineIndependent/intermOut.cpp +++ b/glslang/MachineIndependent/intermOut.cpp @@ -817,6 +817,7 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpConstructStruct: out.debug << "Construct structure"; break; case EOpConstructTextureSampler: out.debug << "Construct combined texture-sampler"; break; case EOpConstructReference: out.debug << "Construct reference"; break; + case EOpConstructCooperativeMatrix: out.debug << "Construct cooperative matrix"; break; case EOpLessThan: out.debug << "Compare Less Than"; break; case EOpGreaterThan: out.debug << "Compare Greater Than"; break; @@ -1066,6 +1067,10 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpWritePackedPrimitiveIndices4x8NV: out.debug << "writePackedPrimitiveIndices4x8NV"; break; #endif + case EOpCooperativeMatrixLoad: out.debug << "Load cooperative matrix"; break; + case EOpCooperativeMatrixStore: out.debug << "Store cooperative matrix"; break; + case EOpCooperativeMatrixMulAdd: out.debug << "MulAdd cooperative matrices"; break; + default: out.debug.message(EPrefixError, "Bad aggregation op"); } diff --git a/glslang/MachineIndependent/localintermediate.h b/glslang/MachineIndependent/localintermediate.h index aecbc6bf..a9433fd7 100755 --- a/glslang/MachineIndependent/localintermediate.h +++ b/glslang/MachineIndependent/localintermediate.h @@ -261,6 +261,7 @@ public: useStorageBuffer(false), useVulkanMemoryModel(false), hlslIoMapping(false), + useVariablePointers(false), textureSamplerTransformMode(EShTexSampTransKeep), needToLegalize(false), binaryDoubleOutput(false), @@ -405,6 +406,12 @@ public: usePhysicalStorageBuffer = true; } bool usingPhysicalStorageBuffer() const { return usePhysicalStorageBuffer; } + void setUseVariablePointers() + { + useVariablePointers = true; + processes.addProcess("use-variable-pointers"); + } + bool usingVariablePointers() const { return useVariablePointers; } template T addCounterBufferName(const T& name) const { return name + implicitCounterName; } bool hasCounterBufferName(const TString& name) const { @@ -491,6 +498,7 @@ public: TIntermTyped* addConversion(TOperator, const TType&, TIntermTyped*) const; std::tuple addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* node1) const; TIntermTyped* addUniShapeConversion(TOperator, const TType&, TIntermTyped*); + TIntermTyped* addConversion(TBasicType convertTo, TIntermTyped* node) const; void addBiShapeConversion(TOperator, TIntermTyped*& lhsNode, TIntermTyped*& rhsNode); TIntermTyped* addShapeConversion(const TType&, TIntermTyped*); TIntermTyped* addBinaryMath(TOperator, TIntermTyped* left, TIntermTyped* right, TSourceLoc); @@ -852,6 +860,7 @@ protected: bool useStorageBuffer; bool useVulkanMemoryModel; bool hlslIoMapping; + bool useVariablePointers; std::set ioAccessed; // set of names of statically read/written I/O that might need extra checking std::vector usedIo[4]; // sets of used locations, one for each of in, out, uniform, and buffers diff --git a/glslang/MachineIndependent/parseVersions.h b/glslang/MachineIndependent/parseVersions.h index b5e229ac..02af76a8 100755 --- a/glslang/MachineIndependent/parseVersions.h +++ b/glslang/MachineIndependent/parseVersions.h @@ -104,6 +104,7 @@ public: virtual bool checkExtensionsRequested(const TSourceLoc&, int numExtensions, const char* const extensions[], const char* featureDesc); virtual void updateExtensionBehavior(const char* const extension, TExtensionBehavior); virtual void checkExtensionStage(const TSourceLoc&, const char* const extension); + virtual void fcoopmatCheck(const TSourceLoc&, const char* op, bool builtIn = false); virtual void C_DECL error(const TSourceLoc&, const char* szReason, const char* szToken, const char* szExtraInfoFormat, ...) = 0; diff --git a/gtests/Spv.FromFile.cpp b/gtests/Spv.FromFile.cpp index 1a144072..28a2f27e 100644 --- a/gtests/Spv.FromFile.cpp +++ b/gtests/Spv.FromFile.cpp @@ -286,6 +286,8 @@ INSTANTIATE_TEST_CASE_P( "spv.constStruct.vert", "spv.controlFlowAttributes.frag", "spv.conversion.frag", + "spv.coopmat.comp", + "spv.coopmat_Error.comp", "spv.dataOut.frag", "spv.dataOutIndirect.frag", "spv.dataOutIndirect.vert", @@ -410,6 +412,7 @@ INSTANTIATE_TEST_CASE_P( ::testing::ValuesIn(std::vector({ "spv.1.3.8bitstorage-ubo.vert", "spv.1.3.8bitstorage-ssbo.vert", + "spv.1.3.coopmat.comp", "spv.deviceGroup.frag", "spv.drawParams.vert", "spv.int8.frag", diff --git a/known_good.json b/known_good.json index 61378945..cf2101bf 100644 --- a/known_good.json +++ b/known_good.json @@ -5,14 +5,14 @@ "site" : "github", "subrepo" : "KhronosGroup/SPIRV-Tools", "subdir" : "External/spirv-tools", - "commit" : "5994ae2a045015004cce24802dc47c33736486ea" + "commit" : "002ef361cabc486a2f3567d646363334d50cc462" }, { "name" : "spirv-tools/external/spirv-headers", "site" : "github", "subrepo" : "KhronosGroup/SPIRV-Headers", "subdir" : "External/spirv-tools/external/spirv-headers", - "commit" : "79b6681aadcb53c27d1052e5f8a0e82a981dbf2f" + "commit" : "e74c389f81915d0a48d6df1af83c3862c5ad85ab" } ] }