diff --git a/SPIRV/GLSL.ext.AMD.h b/SPIRV/GLSL.ext.AMD.h index 59972bc5..a1b9ef95 100644 --- a/SPIRV/GLSL.ext.AMD.h +++ b/SPIRV/GLSL.ext.AMD.h @@ -33,7 +33,7 @@ enum Decoration; enum Op; static const int GLSLextAMDVersion = 100; -static const int GLSLextAMDRevision = 3; +static const int GLSLextAMDRevision = 4; // SPV_AMD_shader_ballot static const char* const E_SPV_AMD_shader_ballot = "SPV_AMD_shader_ballot"; @@ -119,4 +119,7 @@ static const char* const E_SPV_AMD_texture_gather_bias_lod = "SPV_AMD_texture_ga static const Capability OpCapabilityImageGatherBiasLodAMD = static_cast(5009); +// SPV_AMD_gpu_shader_int16 +static const char* const E_SPV_AMD_gpu_shader_int16 = "SPV_AMD_gpu_shader_int16"; + #endif // #ifndef GLSLextAMD_H diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp index f6c3e5d5..9a29b2eb 100755 --- a/SPIRV/GlslangToSpv.cpp +++ b/SPIRV/GlslangToSpv.cpp @@ -1369,6 +1369,10 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI #endif else if (node->getBasicType() == glslang::EbtInt64 || node->getBasicType() == glslang::EbtUint64) one = builder.makeInt64Constant(1); +#ifdef AMD_EXTENSIONS + else if (node->getBasicType() == glslang::EbtInt16 || node->getBasicType() == glslang::EbtUint16) + one = builder.makeInt16Constant(1); +#endif else one = builder.makeIntConstant(1); glslang::TOperator op; @@ -1616,6 +1620,16 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt case glslang::EOpConstructU64Vec2: case glslang::EOpConstructU64Vec3: case glslang::EOpConstructU64Vec4: +#ifdef AMD_EXTENSIONS + case glslang::EOpConstructInt16: + case glslang::EOpConstructI16Vec2: + case glslang::EOpConstructI16Vec3: + case glslang::EOpConstructI16Vec4: + case glslang::EOpConstructUint16: + case glslang::EOpConstructU16Vec2: + case glslang::EOpConstructU16Vec3: + case glslang::EOpConstructU16Vec4: +#endif case glslang::EOpConstructStruct: case glslang::EOpConstructTextureSampler: { @@ -2149,7 +2163,9 @@ spv::Id TGlslangToSpvTraverser::createSpvVariable(const glslang::TIntermSymbol* spv::Id spvType = convertGlslangToSpvType(node->getType()); #ifdef AMD_EXTENSIONS - const bool contains16BitType = node->getType().containsBasicType(glslang::EbtFloat16); + const bool contains16BitType = node->getType().containsBasicType(glslang::EbtFloat16) || + node->getType().containsBasicType(glslang::EbtInt16) || + node->getType().containsBasicType(glslang::EbtUint16); if (contains16BitType) { if (storageClass == spv::StorageClassInput || storageClass == spv::StorageClassOutput) { builder.addExtension(spv::E_SPV_KHR_16bit_storage); @@ -2262,13 +2278,21 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty spvType = builder.makeUintType(32); break; case glslang::EbtInt64: - builder.addCapability(spv::CapabilityInt64); spvType = builder.makeIntType(64); break; case glslang::EbtUint64: - builder.addCapability(spv::CapabilityInt64); spvType = builder.makeUintType(64); break; +#ifdef AMD_EXTENSIONS + case glslang::EbtInt16: + builder.addExtension(spv::E_SPV_AMD_gpu_shader_int16); + spvType = builder.makeIntType(16); + break; + case glslang::EbtUint16: + builder.addExtension(spv::E_SPV_AMD_gpu_shader_int16); + spvType = builder.makeUintType(16); + break; +#endif case glslang::EbtAtomicUint: builder.addCapability(spv::CapabilityAtomicStorage); spvType = builder.makeUintType(32); @@ -3485,10 +3509,11 @@ spv::Id TGlslangToSpvTraverser::createBinaryOperation(glslang::TOperator op, spv spv::Id typeId, spv::Id left, spv::Id right, glslang::TBasicType typeProxy, bool reduceComparison) { - bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64; #ifdef AMD_EXTENSIONS + bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64 || typeProxy == glslang::EbtUint16; bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble || typeProxy == glslang::EbtFloat16; #else + bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64; bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble; #endif bool isBool = typeProxy == glslang::EbtBool; @@ -3815,10 +3840,11 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, spv: spv::Op unaryOp = spv::OpNop; int extBuiltins = -1; int libCall = -1; - bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64; #ifdef AMD_EXTENSIONS + bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64 || typeProxy == glslang::EbtUint16; bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble || typeProxy == glslang::EbtFloat16; #else + bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64; bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble; #endif @@ -3957,6 +3983,12 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, spv: case glslang::EOpDoubleBitsToUint64: case glslang::EOpInt64BitsToDouble: case glslang::EOpUint64BitsToDouble: +#ifdef AMD_EXTENSIONS + case glslang::EOpFloat16BitsToInt16: + case glslang::EOpFloat16BitsToUint16: + case glslang::EOpInt16BitsToFloat16: + case glslang::EOpUint16BitsToFloat16: +#endif unaryOp = spv::OpBitcast; break; @@ -4005,6 +4037,14 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, spv: break; #ifdef AMD_EXTENSIONS + case glslang::EOpPackInt2x16: + case glslang::EOpUnpackInt2x16: + case glslang::EOpPackUint2x16: + case glslang::EOpUnpackUint2x16: + case glslang::EOpPackInt4x16: + case glslang::EOpUnpackInt4x16: + case glslang::EOpPackUint4x16: + case glslang::EOpUnpackUint4x16: case glslang::EOpPackFloat2x16: case glslang::EOpUnpackFloat2x16: unaryOp = spv::OpBitcast; @@ -4204,8 +4244,18 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec case glslang::EOpConvUintToBool: case glslang::EOpConvInt64ToBool: case glslang::EOpConvUint64ToBool: - zero = (op == glslang::EOpConvInt64ToBool || - op == glslang::EOpConvUint64ToBool) ? builder.makeUint64Constant(0) : builder.makeUintConstant(0); +#ifdef AMD_EXTENSIONS + case glslang::EOpConvInt16ToBool: + case glslang::EOpConvUint16ToBool: +#endif + if (op == glslang::EOpConvInt64ToBool || op == glslang::EOpConvUint64ToBool) + zero = builder.makeUint64Constant(0); +#ifdef AMD_EXTENSIONS + else if (op == glslang::EOpConvInt16ToBool || op == glslang::EOpConvUint16ToBool) + zero = builder.makeUint16Constant(0); +#endif + else + zero = builder.makeUintConstant(0); zero = makeSmearedConstant(zero, vectorSize); return builder.createBinOp(spv::OpINotEqual, destType, operand, zero); @@ -4248,15 +4298,53 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec case glslang::EOpConvBoolToInt: case glslang::EOpConvBoolToInt64: - zero = (op == glslang::EOpConvBoolToInt64) ? builder.makeInt64Constant(0) : builder.makeIntConstant(0); - one = (op == glslang::EOpConvBoolToInt64) ? builder.makeInt64Constant(1) : builder.makeIntConstant(1); +#ifdef AMD_EXTENSIONS + case glslang::EOpConvBoolToInt16: +#endif + if (op == glslang::EOpConvBoolToInt64) + zero = builder.makeInt64Constant(0); +#ifdef AMD_EXTENSIONS + else if (op == glslang::EOpConvBoolToInt16) + zero = builder.makeInt16Constant(0); +#endif + else + zero = builder.makeIntConstant(0); + + if (op == glslang::EOpConvBoolToInt64) + one = builder.makeInt64Constant(1); +#ifdef AMD_EXTENSIONS + else if (op == glslang::EOpConvBoolToInt16) + one = builder.makeInt16Constant(1); +#endif + else + one = builder.makeIntConstant(1); + convOp = spv::OpSelect; break; case glslang::EOpConvBoolToUint: case glslang::EOpConvBoolToUint64: - zero = (op == glslang::EOpConvBoolToUint64) ? builder.makeUint64Constant(0) : builder.makeUintConstant(0); - one = (op == glslang::EOpConvBoolToUint64) ? builder.makeUint64Constant(1) : builder.makeUintConstant(1); +#ifdef AMD_EXTENSIONS + case glslang::EOpConvBoolToUint16: +#endif + if (op == glslang::EOpConvBoolToUint64) + zero = builder.makeUint64Constant(0); +#ifdef AMD_EXTENSIONS + else if (op == glslang::EOpConvBoolToUint16) + zero = builder.makeUint16Constant(0); +#endif + else + zero = builder.makeUintConstant(0); + + if (op == glslang::EOpConvBoolToUint64) + one = builder.makeUint64Constant(1); +#ifdef AMD_EXTENSIONS + else if (op == glslang::EOpConvBoolToUint16) + one = builder.makeUint16Constant(1); +#endif + else + one = builder.makeUintConstant(1); + convOp = spv::OpSelect; break; @@ -4265,6 +4353,9 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec case glslang::EOpConvInt64ToFloat: case glslang::EOpConvInt64ToDouble: #ifdef AMD_EXTENSIONS + case glslang::EOpConvInt16ToFloat: + case glslang::EOpConvInt16ToDouble: + case glslang::EOpConvInt16ToFloat16: case glslang::EOpConvIntToFloat16: case glslang::EOpConvInt64ToFloat16: #endif @@ -4276,6 +4367,9 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec case glslang::EOpConvUint64ToFloat: case glslang::EOpConvUint64ToDouble: #ifdef AMD_EXTENSIONS + case glslang::EOpConvUint16ToFloat: + case glslang::EOpConvUint16ToDouble: + case glslang::EOpConvUint16ToFloat16: case glslang::EOpConvUintToFloat16: case glslang::EOpConvUint64ToFloat16: #endif @@ -4300,6 +4394,9 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec case glslang::EOpConvFloatToInt64: case glslang::EOpConvDoubleToInt64: #ifdef AMD_EXTENSIONS + case glslang::EOpConvFloatToInt16: + case glslang::EOpConvDoubleToInt16: + case glslang::EOpConvFloat16ToInt16: case glslang::EOpConvFloat16ToInt: case glslang::EOpConvFloat16ToInt64: #endif @@ -4310,10 +4407,21 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec case glslang::EOpConvIntToUint: case glslang::EOpConvUint64ToInt64: case glslang::EOpConvInt64ToUint64: +#ifdef AMD_EXTENSIONS + case glslang::EOpConvUint16ToInt16: + case glslang::EOpConvInt16ToUint16: +#endif if (builder.isInSpecConstCodeGenMode()) { // Build zero scalar or vector for OpIAdd. - zero = (op == glslang::EOpConvUint64ToInt64 || - op == glslang::EOpConvInt64ToUint64) ? builder.makeUint64Constant(0) : builder.makeUintConstant(0); + if (op == glslang::EOpConvUint64ToInt64 || op == glslang::EOpConvInt64ToUint64) + zero = builder.makeUint64Constant(0); +#ifdef AMD_EXTENSIONS + else if (op == glslang::EOpConvUint16ToInt16 || op == glslang::EOpConvInt16ToUint16) + zero = builder.makeUint16Constant(0); +#endif + else + zero = builder.makeUintConstant(0); + zero = makeSmearedConstant(zero, vectorSize); // Use OpIAdd, instead of OpBitcast to do the conversion when // generating for OpSpecConstantOp instruction. @@ -4328,6 +4436,9 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec case glslang::EOpConvFloatToUint64: case glslang::EOpConvDoubleToUint64: #ifdef AMD_EXTENSIONS + case glslang::EOpConvFloatToUint16: + case glslang::EOpConvDoubleToUint16: + case glslang::EOpConvFloat16ToUint16: case glslang::EOpConvFloat16ToUint: case glslang::EOpConvFloat16ToUint64: #endif @@ -4336,11 +4447,23 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec case glslang::EOpConvIntToInt64: case glslang::EOpConvInt64ToInt: +#ifdef AMD_EXTENSIONS + case glslang::EOpConvIntToInt16: + case glslang::EOpConvInt16ToInt: + case glslang::EOpConvInt64ToInt16: + case glslang::EOpConvInt16ToInt64: +#endif convOp = spv::OpSConvert; break; case glslang::EOpConvUintToUint64: case glslang::EOpConvUint64ToUint: +#ifdef AMD_EXTENSIONS + case glslang::EOpConvUintToUint16: + case glslang::EOpConvUint16ToUint: + case glslang::EOpConvUint64ToUint16: + case glslang::EOpConvUint16ToUint64: +#endif convOp = spv::OpUConvert; break; @@ -4348,24 +4471,58 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec case glslang::EOpConvInt64ToUint: case glslang::EOpConvUint64ToInt: case glslang::EOpConvUintToInt64: +#ifdef AMD_EXTENSIONS + case glslang::EOpConvInt16ToUint: + case glslang::EOpConvUintToInt16: + case glslang::EOpConvInt16ToUint64: + case glslang::EOpConvUint64ToInt16: + case glslang::EOpConvUint16ToInt: + case glslang::EOpConvIntToUint16: + case glslang::EOpConvUint16ToInt64: + case glslang::EOpConvInt64ToUint16: +#endif // OpSConvert/OpUConvert + OpBitCast switch (op) { case glslang::EOpConvIntToUint64: +#ifdef AMD_EXTENSIONS + case glslang::EOpConvInt16ToUint64: +#endif convOp = spv::OpSConvert; type = builder.makeIntType(64); break; case glslang::EOpConvInt64ToUint: +#ifdef AMD_EXTENSIONS + case glslang::EOpConvInt16ToUint: +#endif convOp = spv::OpSConvert; type = builder.makeIntType(32); break; case glslang::EOpConvUint64ToInt: +#ifdef AMD_EXTENSIONS + case glslang::EOpConvUint16ToInt: +#endif convOp = spv::OpUConvert; type = builder.makeUintType(32); break; case glslang::EOpConvUintToInt64: +#ifdef AMD_EXTENSIONS + case glslang::EOpConvUint16ToInt64: +#endif convOp = spv::OpUConvert; type = builder.makeUintType(64); break; +#ifdef AMD_EXTENSIONS + case glslang::EOpConvUintToInt16: + case glslang::EOpConvUint64ToInt16: + convOp = spv::OpUConvert; + type = builder.makeUintType(16); + break; + case glslang::EOpConvIntToUint16: + case glslang::EOpConvInt64ToUint16: + convOp = spv::OpSConvert; + type = builder.makeIntType(16); + break; +#endif default: assert(0); break; @@ -4378,8 +4535,22 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec if (builder.isInSpecConstCodeGenMode()) { // Build zero scalar or vector for OpIAdd. - zero = (op == glslang::EOpConvIntToUint64 || - op == glslang::EOpConvUintToInt64) ? builder.makeUint64Constant(0) : builder.makeUintConstant(0); +#ifdef AMD_EXTENSIONS + if (op == glslang::EOpConvIntToUint64 || op == glslang::EOpConvUintToInt64 || + op == glslang::EOpConvInt16ToUint64 || op == glslang::EOpConvUint16ToInt64) + zero = builder.makeUint64Constant(0); + else if (op == glslang::EOpConvIntToUint16 || op == glslang::EOpConvUintToInt16 || + op == glslang::EOpConvInt64ToUint16 || op == glslang::EOpConvUint64ToInt16) + zero = builder.makeUint16Constant(0); + else + zero = builder.makeUintConstant(0); +#else + if (op == glslang::EOpConvIntToUint64 || op == glslang::EOpConvUintToInt64) + zero = builder.makeUint64Constant(0); + else + zero = builder.makeUintConstant(0); +#endif + zero = makeSmearedConstant(zero, vectorSize); // Use OpIAdd, instead of OpBitcast to do the conversion when // generating for OpSpecConstantOp instruction. @@ -4765,10 +4936,11 @@ spv::Id TGlslangToSpvTraverser::CreateInvocationsVectorOperation(spv::Op op, spv spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId, std::vector& operands, glslang::TBasicType typeProxy) { - bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64; #ifdef AMD_EXTENSIONS + bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64 || typeProxy == glslang::EbtUint16; bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble || typeProxy == glslang::EbtFloat16; #else + bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64; bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble; #endif @@ -5353,6 +5525,14 @@ spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glsla case glslang::EbtUint64: spvConsts.push_back(builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const())); break; +#ifdef AMD_EXTENSIONS + case glslang::EbtInt16: + spvConsts.push_back(builder.makeInt16Constant(zero ? 0 : (short)consts[nextConst].getIConst())); + break; + case glslang::EbtUint16: + spvConsts.push_back(builder.makeUint16Constant(zero ? 0 : (unsigned short)consts[nextConst].getUConst())); + break; +#endif case glslang::EbtFloat: spvConsts.push_back(builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst())); break; @@ -5390,6 +5570,14 @@ spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glsla case glslang::EbtUint64: scalar = builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const(), specConstant); break; +#ifdef AMD_EXTENSIONS + case glslang::EbtInt16: + scalar = builder.makeInt16Constant(zero ? 0 : (short)consts[nextConst].getIConst(), specConstant); + break; + case glslang::EbtUint16: + scalar = builder.makeUint16Constant(zero ? 0 : (unsigned short)consts[nextConst].getUConst(), specConstant); + break; +#endif case glslang::EbtFloat: scalar = builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant); break; diff --git a/SPIRV/SpvBuilder.h b/SPIRV/SpvBuilder.h index 60d97e9c..92f5084c 100755 --- a/SPIRV/SpvBuilder.h +++ b/SPIRV/SpvBuilder.h @@ -214,6 +214,10 @@ public: Id makeUintConstant(unsigned u, bool specConstant = false) { return makeIntConstant(makeUintType(32), u, specConstant); } Id makeInt64Constant(long long i, bool specConstant = false) { return makeInt64Constant(makeIntType(64), (unsigned long long)i, specConstant); } Id makeUint64Constant(unsigned long long u, bool specConstant = false) { return makeInt64Constant(makeUintType(64), u, specConstant); } +#ifdef AMD_EXTENSIONS + Id makeInt16Constant(short i, bool specConstant = false) { return makeIntConstant(makeIntType(16), (unsigned)((unsigned short)i), specConstant); } + Id makeUint16Constant(unsigned short u, bool specConstant = false) { return makeIntConstant(makeUintType(16), (unsigned)u, specConstant); } +#endif Id makeFloatConstant(float f, bool specConstant = false); Id makeDoubleConstant(double d, bool specConstant = false); #ifdef AMD_EXTENSIONS diff --git a/Test/baseResults/spv.int16.frag.out b/Test/baseResults/spv.int16.frag.out new file mode 100644 index 00000000..7442cffd --- /dev/null +++ b/Test/baseResults/spv.int16.frag.out @@ -0,0 +1,779 @@ +spv.int16.frag +// Module Version 10000 +// Generated by (magic number): 80001 +// Id's are bound by 561 + + Capability Shader + Capability Float16 + Capability Float64 + Capability Int64 + Capability Int16 + Capability StorageUniform16 + Capability StorageInputOutput16 + Extension "SPV_AMD_gpu_shader_half_float" + Extension "SPV_AMD_gpu_shader_int16" + Extension "SPV_KHR_16bit_storage" + 1: ExtInstImport "GLSL.std.450" + MemoryModel Logical GLSL450 + EntryPoint Fragment 4 "main" 520 522 + ExecutionMode 4 OriginUpperLeft + Source GLSL 450 + SourceExtension "GL_AMD_gpu_shader_half_float" + SourceExtension "GL_AMD_gpu_shader_int16" + SourceExtension "GL_ARB_gpu_shader_int64" + Name 4 "main" + Name 6 "literal(" + Name 8 "operators(" + Name 10 "typeCast(" + Name 12 "builtinFuncs(" + Name 16 "u16" + Name 25 "Uniforms" + MemberName 25(Uniforms) 0 "i" + Name 27 "" + Name 34 "indexable" + Name 45 "indexable" + Name 51 "u16v" + Name 57 "i16" + Name 70 "u16" + Name 108 "i" + Name 130 "b" + Name 151 "u" + Name 190 "i16v" + Name 193 "bv" + Name 201 "u16v" + Name 214 "iv" + Name 227 "uv" + Name 241 "fv" + Name 253 "dv" + Name 265 "f16v" + Name 277 "i64v" + Name 291 "u64v" + Name 306 "i16v" + Name 312 "i16" + Name 320 "u16v" + Name 322 "u16" + Name 394 "f16v" + Name 397 "exp" + Name 398 "ResType" + Name 419 "packi" + Name 424 "packu" + Name 433 "packi64" + Name 442 "packu64" + Name 451 "bv" + Name 516 "Block" + MemberName 516(Block) 0 "i16v" + MemberName 516(Block) 1 "u16" + Name 518 "block" + Name 520 "iu16v" + Name 522 "ii16" + Name 523 "si64" + Name 524 "su64" + Name 525 "si" + Name 526 "su" + Name 527 "sb" + Name 528 "si16" + Name 529 "su16" + MemberDecorate 25(Uniforms) 0 Offset 0 + Decorate 25(Uniforms) Block + Decorate 27 DescriptorSet 0 + Decorate 27 Binding 0 + MemberDecorate 516(Block) 0 Offset 0 + MemberDecorate 516(Block) 1 Offset 6 + Decorate 516(Block) Block + Decorate 518(block) DescriptorSet 0 + Decorate 518(block) Binding 1 + Decorate 520(iu16v) Flat + Decorate 520(iu16v) Location 0 + Decorate 522(ii16) Flat + Decorate 522(ii16) Location 1 + Decorate 523(si64) SpecId 100 + Decorate 524(su64) SpecId 101 + Decorate 525(si) SpecId 102 + Decorate 526(su) SpecId 103 + Decorate 527(sb) SpecId 104 + Decorate 528(si16) SpecId 105 + Decorate 529(su16) SpecId 106 + 2: TypeVoid + 3: TypeFunction 2 + 14: TypeInt 16 0 + 15: TypePointer Function 14(int) + 17: TypeInt 16 1 + 18: TypeInt 32 0 + 19: 18(int) Constant 3 + 20: TypeArray 17(int) 19 + 21: 17(int) Constant 273 + 22: 17(int) Constant 65534 + 23: 17(int) Constant 256 + 24: 20 ConstantComposite 21 22 23 + 25(Uniforms): TypeStruct 18(int) + 26: TypePointer Uniform 25(Uniforms) + 27: 26(ptr) Variable Uniform + 28: TypeInt 32 1 + 29: 28(int) Constant 0 + 30: TypePointer Uniform 18(int) + 33: TypePointer Function 20 + 35: TypePointer Function 17(int) + 39: TypeArray 14(int) 19 + 40: 14(int) Constant 65535 + 41: 39 ConstantComposite 40 40 40 + 44: TypePointer Function 39 + 49: TypeVector 14(int) 3 + 50: TypePointer Function 49(ivec3) + 53: 17(int) Constant 1 + 54: TypeVector 17(int) 3 + 107: TypePointer Function 28(int) + 111: TypeVector 28(int) 3 + 114: 18(int) Constant 1 + 120: 18(int) Constant 2 + 128: TypeBool + 129: TypePointer Function 128(bool) + 131: 18(int) Constant 0 + 150: TypePointer Function 18(int) + 188: TypeVector 17(int) 2 + 189: TypePointer Function 188(ivec2) + 191: TypeVector 128(bool) 2 + 192: TypePointer Function 191(bvec2) + 195: 17(int) Constant 0 + 196: 188(ivec2) ConstantComposite 195 195 + 197: 188(ivec2) ConstantComposite 53 53 + 199: TypeVector 14(int) 2 + 200: TypePointer Function 199(ivec2) + 203: 14(int) Constant 0 + 204: 14(int) Constant 1 + 205: 199(ivec2) ConstantComposite 203 203 + 206: 199(ivec2) ConstantComposite 204 204 + 212: TypeVector 28(int) 2 + 213: TypePointer Function 212(ivec2) + 223: TypeVector 18(int) 2 + 226: TypePointer Function 223(ivec2) + 238: TypeFloat 32 + 239: TypeVector 238(float) 2 + 240: TypePointer Function 239(fvec2) + 250: TypeFloat 64 + 251: TypeVector 250(float) 2 + 252: TypePointer Function 251(fvec2) + 262: TypeFloat 16 + 263: TypeVector 262(float) 2 + 264: TypePointer Function 263(fvec2) + 274: TypeInt 64 1 + 275: TypeVector 274(int) 2 + 276: TypePointer Function 275(ivec2) + 286: TypeInt 64 0 + 287: TypeVector 286(int) 2 + 290: TypePointer Function 287(ivec2) + 317: 17(int) Constant 65535 + 318: 188(ivec2) ConstantComposite 317 317 + 327: 49(ivec3) ConstantComposite 203 203 203 + 369: 128(bool) ConstantTrue + 376: 128(bool) ConstantFalse + 377: 191(bvec2) ConstantComposite 376 376 + 389: TypeVector 128(bool) 3 + 390: 389(bvec3) ConstantComposite 376 376 376 + 392: TypeVector 262(float) 3 + 393: TypePointer Function 392(fvec3) + 396: TypePointer Function 54(ivec3) + 398(ResType): TypeStruct 392(fvec3) 54(ivec3) + 408: TypePointer Function 262(float) + 432: TypePointer Function 274(int) + 435: TypeVector 17(int) 4 + 441: TypePointer Function 286(int) + 444: TypeVector 14(int) 4 + 450: TypePointer Function 389(bvec3) + 516(Block): TypeStruct 54(ivec3) 14(int) + 517: TypePointer Uniform 516(Block) + 518(block): 517(ptr) Variable Uniform + 519: TypePointer Input 49(ivec3) + 520(iu16v): 519(ptr) Variable Input + 521: TypePointer Input 17(int) + 522(ii16): 521(ptr) Variable Input + 523(si64): 274(int) SpecConstant 4294967286 4294967295 + 524(su64): 286(int) SpecConstant 20 0 + 525(si): 28(int) SpecConstant 4294967291 + 526(su): 18(int) SpecConstant 4 + 527(sb): 128(bool) SpecConstantTrue + 528(si16): 17(int) SpecConstant 65531 + 529(su16): 14(int) SpecConstant 4 + 530: 128(bool) SpecConstantOp 171 528(si16) 203 + 531: 128(bool) SpecConstantOp 171 529(su16) 203 + 532: 17(int) SpecConstantOp 169 527(sb) 53 195 + 533: 14(int) SpecConstantOp 169 527(sb) 204 203 + 534: 28(int) SpecConstantOp 114 528(si16) + 535: 18(int) SpecConstantOp 113 529(su16) + 536: 28(int) SpecConstantOp 128 535 131 + 537: 17(int) SpecConstantOp 114 525(si) + 538: 17(int) SpecConstantOp 114 525(si) + 539: 14(int) SpecConstantOp 128 538 203 + 540: 28(int) SpecConstantOp 114 528(si16) + 541: 18(int) SpecConstantOp 128 540 131 + 542: 18(int) SpecConstantOp 113 529(su16) + 543: 14(int) SpecConstantOp 113 526(su) + 544: 17(int) SpecConstantOp 128 543 203 + 545: 14(int) SpecConstantOp 113 526(su) + 546: 274(int) SpecConstantOp 114 528(si16) + 547: 286(int) SpecConstantOp 113 529(su16) + 548: 286(int) Constant 0 0 + 549: 274(int) SpecConstantOp 128 547 548 + 550: 17(int) SpecConstantOp 114 523(si64) + 551: 17(int) SpecConstantOp 114 523(si64) + 552: 14(int) SpecConstantOp 128 551 203 + 553: 274(int) SpecConstantOp 114 528(si16) + 554: 286(int) SpecConstantOp 128 553 548 + 555: 286(int) SpecConstantOp 113 529(su16) + 556: 14(int) SpecConstantOp 113 524(su64) + 557: 17(int) SpecConstantOp 128 556 203 + 558: 14(int) SpecConstantOp 113 524(su64) + 559: 14(int) SpecConstantOp 128 528(si16) 203 + 560: 17(int) SpecConstantOp 128 529(su16) 203 + 4(main): 2 Function None 3 + 5: Label + 512: 2 FunctionCall 6(literal() + 513: 2 FunctionCall 8(operators() + 514: 2 FunctionCall 10(typeCast() + 515: 2 FunctionCall 12(builtinFuncs() + Return + FunctionEnd + 6(literal(): 2 Function None 3 + 7: Label + 16(u16): 15(ptr) Variable Function + 34(indexable): 33(ptr) Variable Function + 45(indexable): 44(ptr) Variable Function + 31: 30(ptr) AccessChain 27 29 + 32: 18(int) Load 31 + Store 34(indexable) 24 + 36: 35(ptr) AccessChain 34(indexable) 32 + 37: 17(int) Load 36 + 38: 14(int) Bitcast 37 + 42: 30(ptr) AccessChain 27 29 + 43: 18(int) Load 42 + Store 45(indexable) 41 + 46: 15(ptr) AccessChain 45(indexable) 43 + 47: 14(int) Load 46 + 48: 14(int) IAdd 38 47 + Store 16(u16) 48 + Return + FunctionEnd + 8(operators(): 2 Function None 3 + 9: Label + 51(u16v): 50(ptr) Variable Function + 57(i16): 35(ptr) Variable Function + 70(u16): 15(ptr) Variable Function + 108(i): 107(ptr) Variable Function + 130(b): 129(ptr) Variable Function + 151(u): 150(ptr) Variable Function + 52: 49(ivec3) Load 51(u16v) + 55: 54(ivec3) CompositeConstruct 53 53 53 + 56: 49(ivec3) IAdd 52 55 + Store 51(u16v) 56 + 58: 17(int) Load 57(i16) + 59: 17(int) ISub 58 53 + Store 57(i16) 59 + 60: 17(int) Load 57(i16) + 61: 17(int) IAdd 60 53 + Store 57(i16) 61 + 62: 49(ivec3) Load 51(u16v) + 63: 54(ivec3) CompositeConstruct 53 53 53 + 64: 49(ivec3) ISub 62 63 + Store 51(u16v) 64 + 65: 49(ivec3) Load 51(u16v) + 66: 49(ivec3) Not 65 + Store 51(u16v) 66 + 67: 17(int) Load 57(i16) + Store 57(i16) 67 + 68: 49(ivec3) Load 51(u16v) + 69: 49(ivec3) SNegate 68 + Store 51(u16v) 69 + 71: 17(int) Load 57(i16) + 72: 14(int) Bitcast 71 + 73: 14(int) Load 70(u16) + 74: 14(int) IAdd 73 72 + Store 70(u16) 74 + 75: 49(ivec3) Load 51(u16v) + 76: 49(ivec3) Load 51(u16v) + 77: 49(ivec3) ISub 76 75 + Store 51(u16v) 77 + 78: 17(int) Load 57(i16) + 79: 17(int) Load 57(i16) + 80: 17(int) IMul 79 78 + Store 57(i16) 80 + 81: 49(ivec3) Load 51(u16v) + 82: 49(ivec3) Load 51(u16v) + 83: 49(ivec3) UDiv 82 81 + Store 51(u16v) 83 + 84: 17(int) Load 57(i16) + 85: 14(int) Bitcast 84 + 86: 49(ivec3) Load 51(u16v) + 87: 49(ivec3) CompositeConstruct 85 85 85 + 88: 49(ivec3) UMod 86 87 + Store 51(u16v) 88 + 89: 49(ivec3) Load 51(u16v) + 90: 49(ivec3) Load 51(u16v) + 91: 49(ivec3) IAdd 89 90 + Store 51(u16v) 91 + 92: 17(int) Load 57(i16) + 93: 14(int) Bitcast 92 + 94: 14(int) Load 70(u16) + 95: 14(int) ISub 93 94 + Store 70(u16) 95 + 96: 49(ivec3) Load 51(u16v) + 97: 17(int) Load 57(i16) + 98: 14(int) Bitcast 97 + 99: 49(ivec3) CompositeConstruct 98 98 98 + 100: 49(ivec3) IMul 96 99 + Store 51(u16v) 100 + 101: 17(int) Load 57(i16) + 102: 17(int) Load 57(i16) + 103: 17(int) IMul 101 102 + Store 57(i16) 103 + 104: 17(int) Load 57(i16) + 105: 17(int) Load 57(i16) + 106: 17(int) SMod 104 105 + Store 57(i16) 106 + 109: 28(int) Load 108(i) + 110: 49(ivec3) Load 51(u16v) + 112: 111(ivec3) CompositeConstruct 109 109 109 + 113: 49(ivec3) ShiftLeftLogical 110 112 + Store 51(u16v) 113 + 115: 15(ptr) AccessChain 51(u16v) 114 + 116: 14(int) Load 115 + 117: 17(int) Load 57(i16) + 118: 17(int) ShiftRightArithmetic 117 116 + Store 57(i16) 118 + 119: 17(int) Load 57(i16) + 121: 15(ptr) AccessChain 51(u16v) 120 + 122: 14(int) Load 121 + 123: 17(int) ShiftLeftLogical 119 122 + Store 57(i16) 123 + 124: 49(ivec3) Load 51(u16v) + 125: 17(int) Load 57(i16) + 126: 54(ivec3) CompositeConstruct 125 125 125 + 127: 49(ivec3) ShiftLeftLogical 124 126 + Store 51(u16v) 127 + 132: 15(ptr) AccessChain 51(u16v) 131 + 133: 14(int) Load 132 + 134: 17(int) Load 57(i16) + 135: 14(int) Bitcast 134 + 136: 128(bool) INotEqual 133 135 + Store 130(b) 136 + 137: 17(int) Load 57(i16) + 138: 14(int) Bitcast 137 + 139: 15(ptr) AccessChain 51(u16v) 131 + 140: 14(int) Load 139 + 141: 128(bool) IEqual 138 140 + Store 130(b) 141 + 142: 15(ptr) AccessChain 51(u16v) 131 + 143: 14(int) Load 142 + 144: 15(ptr) AccessChain 51(u16v) 114 + 145: 14(int) Load 144 + 146: 128(bool) UGreaterThan 143 145 + Store 130(b) 146 + 147: 17(int) Load 57(i16) + 148: 28(int) SConvert 147 + 149: 18(int) Bitcast 148 + 152: 18(int) Load 151(u) + 153: 128(bool) ULessThan 149 152 + Store 130(b) 153 + 154: 15(ptr) AccessChain 51(u16v) 114 + 155: 14(int) Load 154 + 156: 15(ptr) AccessChain 51(u16v) 131 + 157: 14(int) Load 156 + 158: 128(bool) UGreaterThanEqual 155 157 + Store 130(b) 158 + 159: 17(int) Load 57(i16) + 160: 28(int) SConvert 159 + 161: 28(int) Load 108(i) + 162: 128(bool) SLessThanEqual 160 161 + Store 130(b) 162 + 163: 17(int) Load 57(i16) + 164: 14(int) Bitcast 163 + 165: 49(ivec3) Load 51(u16v) + 166: 49(ivec3) CompositeConstruct 164 164 164 + 167: 49(ivec3) BitwiseOr 165 166 + Store 51(u16v) 167 + 168: 17(int) Load 57(i16) + 169: 14(int) Bitcast 168 + 170: 14(int) Load 70(u16) + 171: 14(int) BitwiseOr 169 170 + Store 70(u16) 171 + 172: 17(int) Load 57(i16) + 173: 17(int) Load 57(i16) + 174: 17(int) BitwiseAnd 173 172 + Store 57(i16) 174 + 175: 49(ivec3) Load 51(u16v) + 176: 49(ivec3) Load 51(u16v) + 177: 49(ivec3) BitwiseAnd 175 176 + Store 51(u16v) 177 + 178: 17(int) Load 57(i16) + 179: 14(int) Bitcast 178 + 180: 49(ivec3) Load 51(u16v) + 181: 49(ivec3) CompositeConstruct 179 179 179 + 182: 49(ivec3) BitwiseXor 180 181 + Store 51(u16v) 182 + 183: 49(ivec3) Load 51(u16v) + 184: 17(int) Load 57(i16) + 185: 14(int) Bitcast 184 + 186: 49(ivec3) CompositeConstruct 185 185 185 + 187: 49(ivec3) BitwiseXor 183 186 + Store 51(u16v) 187 + Return + FunctionEnd + 10(typeCast(): 2 Function None 3 + 11: Label + 190(i16v): 189(ptr) Variable Function + 193(bv): 192(ptr) Variable Function + 201(u16v): 200(ptr) Variable Function + 214(iv): 213(ptr) Variable Function + 227(uv): 226(ptr) Variable Function + 241(fv): 240(ptr) Variable Function + 253(dv): 252(ptr) Variable Function + 265(f16v): 264(ptr) Variable Function + 277(i64v): 276(ptr) Variable Function + 291(u64v): 290(ptr) Variable Function + 194: 191(bvec2) Load 193(bv) + 198: 188(ivec2) Select 194 197 196 + Store 190(i16v) 198 + 202: 191(bvec2) Load 193(bv) + 207: 199(ivec2) Select 202 206 205 + Store 201(u16v) 207 + 208: 188(ivec2) Load 190(i16v) + 209: 191(bvec2) INotEqual 208 205 + Store 193(bv) 209 + 210: 199(ivec2) Load 201(u16v) + 211: 191(bvec2) INotEqual 210 205 + Store 193(bv) 211 + 215: 212(ivec2) Load 214(iv) + 216: 188(ivec2) SConvert 215 + Store 190(i16v) 216 + 217: 212(ivec2) Load 214(iv) + 218: 188(ivec2) SConvert 217 + 219: 199(ivec2) Bitcast 218 + Store 201(u16v) 219 + 220: 188(ivec2) Load 190(i16v) + 221: 212(ivec2) SConvert 220 + Store 214(iv) 221 + 222: 199(ivec2) Load 201(u16v) + 224: 223(ivec2) UConvert 222 + 225: 212(ivec2) Bitcast 224 + Store 214(iv) 225 + 228: 223(ivec2) Load 227(uv) + 229: 199(ivec2) UConvert 228 + 230: 188(ivec2) Bitcast 229 + Store 190(i16v) 230 + 231: 223(ivec2) Load 227(uv) + 232: 199(ivec2) UConvert 231 + Store 201(u16v) 232 + 233: 188(ivec2) Load 190(i16v) + 234: 212(ivec2) SConvert 233 + 235: 223(ivec2) Bitcast 234 + Store 227(uv) 235 + 236: 199(ivec2) Load 201(u16v) + 237: 223(ivec2) UConvert 236 + Store 227(uv) 237 + 242: 239(fvec2) Load 241(fv) + 243: 188(ivec2) ConvertFToS 242 + Store 190(i16v) 243 + 244: 239(fvec2) Load 241(fv) + 245: 199(ivec2) ConvertFToU 244 + Store 201(u16v) 245 + 246: 188(ivec2) Load 190(i16v) + 247: 239(fvec2) ConvertSToF 246 + Store 241(fv) 247 + 248: 199(ivec2) Load 201(u16v) + 249: 239(fvec2) ConvertUToF 248 + Store 241(fv) 249 + 254: 251(fvec2) Load 253(dv) + 255: 188(ivec2) ConvertFToS 254 + Store 190(i16v) 255 + 256: 251(fvec2) Load 253(dv) + 257: 199(ivec2) ConvertFToU 256 + Store 201(u16v) 257 + 258: 188(ivec2) Load 190(i16v) + 259: 251(fvec2) ConvertSToF 258 + Store 253(dv) 259 + 260: 199(ivec2) Load 201(u16v) + 261: 251(fvec2) ConvertUToF 260 + Store 253(dv) 261 + 266: 263(fvec2) Load 265(f16v) + 267: 188(ivec2) ConvertFToS 266 + Store 190(i16v) 267 + 268: 263(fvec2) Load 265(f16v) + 269: 199(ivec2) ConvertFToU 268 + Store 201(u16v) 269 + 270: 188(ivec2) Load 190(i16v) + 271: 263(fvec2) ConvertSToF 270 + Store 265(f16v) 271 + 272: 199(ivec2) Load 201(u16v) + 273: 263(fvec2) ConvertUToF 272 + Store 265(f16v) 273 + 278: 275(ivec2) Load 277(i64v) + 279: 188(ivec2) SConvert 278 + Store 190(i16v) 279 + 280: 275(ivec2) Load 277(i64v) + 281: 188(ivec2) SConvert 280 + 282: 199(ivec2) Bitcast 281 + Store 201(u16v) 282 + 283: 188(ivec2) Load 190(i16v) + 284: 275(ivec2) SConvert 283 + Store 277(i64v) 284 + 285: 199(ivec2) Load 201(u16v) + 288: 287(ivec2) UConvert 285 + 289: 275(ivec2) Bitcast 288 + Store 277(i64v) 289 + 292: 287(ivec2) Load 291(u64v) + 293: 199(ivec2) UConvert 292 + 294: 188(ivec2) Bitcast 293 + Store 190(i16v) 294 + 295: 287(ivec2) Load 291(u64v) + 296: 199(ivec2) UConvert 295 + Store 201(u16v) 296 + 297: 188(ivec2) Load 190(i16v) + 298: 275(ivec2) SConvert 297 + 299: 287(ivec2) Bitcast 298 + Store 291(u64v) 299 + 300: 199(ivec2) Load 201(u16v) + 301: 287(ivec2) UConvert 300 + Store 291(u64v) 301 + 302: 199(ivec2) Load 201(u16v) + 303: 188(ivec2) Bitcast 302 + Store 190(i16v) 303 + 304: 188(ivec2) Load 190(i16v) + 305: 199(ivec2) Bitcast 304 + Store 201(u16v) 305 + Return + FunctionEnd +12(builtinFuncs(): 2 Function None 3 + 13: Label + 306(i16v): 189(ptr) Variable Function + 312(i16): 35(ptr) Variable Function + 320(u16v): 50(ptr) Variable Function + 322(u16): 15(ptr) Variable Function + 394(f16v): 393(ptr) Variable Function + 397(exp): 396(ptr) Variable Function + 419(packi): 107(ptr) Variable Function + 424(packu): 150(ptr) Variable Function + 433(packi64): 432(ptr) Variable Function + 442(packu64): 441(ptr) Variable Function + 451(bv): 450(ptr) Variable Function + 307: 188(ivec2) Load 306(i16v) + 308: 188(ivec2) ExtInst 1(GLSL.std.450) 5(SAbs) 307 + Store 306(i16v) 308 + 309: 188(ivec2) Load 306(i16v) + 310: 188(ivec2) ExtInst 1(GLSL.std.450) 7(SSign) 309 + Store 306(i16v) 310 + 311: 188(ivec2) Load 306(i16v) + 313: 17(int) Load 312(i16) + 314: 188(ivec2) CompositeConstruct 313 313 + 315: 188(ivec2) ExtInst 1(GLSL.std.450) 39(SMin) 311 314 + Store 306(i16v) 315 + 316: 188(ivec2) Load 306(i16v) + 319: 188(ivec2) ExtInst 1(GLSL.std.450) 39(SMin) 316 318 + Store 306(i16v) 319 + 321: 49(ivec3) Load 320(u16v) + 323: 14(int) Load 322(u16) + 324: 49(ivec3) CompositeConstruct 323 323 323 + 325: 49(ivec3) ExtInst 1(GLSL.std.450) 38(UMin) 321 324 + Store 320(u16v) 325 + 326: 49(ivec3) Load 320(u16v) + 328: 49(ivec3) ExtInst 1(GLSL.std.450) 38(UMin) 326 327 + Store 320(u16v) 328 + 329: 188(ivec2) Load 306(i16v) + 330: 17(int) Load 312(i16) + 331: 188(ivec2) CompositeConstruct 330 330 + 332: 188(ivec2) ExtInst 1(GLSL.std.450) 42(SMax) 329 331 + Store 306(i16v) 332 + 333: 188(ivec2) Load 306(i16v) + 334: 188(ivec2) ExtInst 1(GLSL.std.450) 42(SMax) 333 318 + Store 306(i16v) 334 + 335: 49(ivec3) Load 320(u16v) + 336: 14(int) Load 322(u16) + 337: 49(ivec3) CompositeConstruct 336 336 336 + 338: 49(ivec3) ExtInst 1(GLSL.std.450) 41(UMax) 335 337 + Store 320(u16v) 338 + 339: 49(ivec3) Load 320(u16v) + 340: 49(ivec3) ExtInst 1(GLSL.std.450) 41(UMax) 339 327 + Store 320(u16v) 340 + 341: 188(ivec2) Load 306(i16v) + 342: 17(int) Load 312(i16) + 343: 17(int) SNegate 342 + 344: 17(int) Load 312(i16) + 345: 188(ivec2) CompositeConstruct 343 343 + 346: 188(ivec2) CompositeConstruct 344 344 + 347: 188(ivec2) ExtInst 1(GLSL.std.450) 45(SClamp) 341 345 346 + Store 306(i16v) 347 + 348: 188(ivec2) Load 306(i16v) + 349: 188(ivec2) Load 306(i16v) + 350: 188(ivec2) SNegate 349 + 351: 188(ivec2) Load 306(i16v) + 352: 188(ivec2) ExtInst 1(GLSL.std.450) 45(SClamp) 348 350 351 + Store 306(i16v) 352 + 353: 49(ivec3) Load 320(u16v) + 354: 14(int) Load 322(u16) + 355: 14(int) SNegate 354 + 356: 14(int) Load 322(u16) + 357: 49(ivec3) CompositeConstruct 355 355 355 + 358: 49(ivec3) CompositeConstruct 356 356 356 + 359: 49(ivec3) ExtInst 1(GLSL.std.450) 44(UClamp) 353 357 358 + Store 320(u16v) 359 + 360: 49(ivec3) Load 320(u16v) + 361: 49(ivec3) Load 320(u16v) + 362: 49(ivec3) SNegate 361 + 363: 49(ivec3) Load 320(u16v) + 364: 49(ivec3) ExtInst 1(GLSL.std.450) 44(UClamp) 360 362 363 + Store 320(u16v) 364 + 365: 35(ptr) AccessChain 306(i16v) 131 + 366: 17(int) Load 365 + 367: 35(ptr) AccessChain 306(i16v) 114 + 368: 17(int) Load 367 + 370: 17(int) Select 369 368 366 + Store 312(i16) 370 + 371: 17(int) Load 312(i16) + 372: 188(ivec2) CompositeConstruct 371 371 + 373: 17(int) Load 312(i16) + 374: 17(int) SNegate 373 + 375: 188(ivec2) CompositeConstruct 374 374 + 378: 188(ivec2) Select 377 375 372 + Store 306(i16v) 378 + 379: 15(ptr) AccessChain 320(u16v) 131 + 380: 14(int) Load 379 + 381: 15(ptr) AccessChain 320(u16v) 114 + 382: 14(int) Load 381 + 383: 14(int) Select 369 382 380 + Store 322(u16) 383 + 384: 14(int) Load 322(u16) + 385: 49(ivec3) CompositeConstruct 384 384 384 + 386: 14(int) Load 322(u16) + 387: 14(int) SNegate 386 + 388: 49(ivec3) CompositeConstruct 387 387 387 + 391: 49(ivec3) Select 390 388 385 + Store 320(u16v) 391 + 395: 392(fvec3) Load 394(f16v) + 399:398(ResType) ExtInst 1(GLSL.std.450) 52(FrexpStruct) 395 + 400: 54(ivec3) CompositeExtract 399 1 + Store 397(exp) 400 + 401: 392(fvec3) CompositeExtract 399 0 + Store 394(f16v) 401 + 402: 392(fvec3) Load 394(f16v) + 403: 54(ivec3) Load 397(exp) + 404: 392(fvec3) ExtInst 1(GLSL.std.450) 53(Ldexp) 402 403 + Store 394(f16v) 404 + 405: 392(fvec3) Load 394(f16v) + 406: 263(fvec2) VectorShuffle 405 405 0 1 + 407: 188(ivec2) Bitcast 406 + Store 306(i16v) 407 + 409: 408(ptr) AccessChain 394(f16v) 120 + 410: 262(float) Load 409 + 411: 14(int) Bitcast 410 + 412: 15(ptr) AccessChain 320(u16v) 131 + Store 412 411 + 413: 188(ivec2) Load 306(i16v) + 414: 263(fvec2) Bitcast 413 + 415: 392(fvec3) Load 394(f16v) + 416: 392(fvec3) VectorShuffle 415 414 3 4 2 + Store 394(f16v) 416 + 417: 49(ivec3) Load 320(u16v) + 418: 392(fvec3) Bitcast 417 + Store 394(f16v) 418 + 420: 188(ivec2) Load 306(i16v) + 421: 28(int) Bitcast 420 + Store 419(packi) 421 + 422: 28(int) Load 419(packi) + 423: 188(ivec2) Bitcast 422 + Store 306(i16v) 423 + 425: 49(ivec3) Load 320(u16v) + 426: 199(ivec2) VectorShuffle 425 425 0 1 + 427: 18(int) Bitcast 426 + Store 424(packu) 427 + 428: 18(int) Load 424(packu) + 429: 199(ivec2) Bitcast 428 + 430: 49(ivec3) Load 320(u16v) + 431: 49(ivec3) VectorShuffle 430 429 3 4 2 + Store 320(u16v) 431 + 434: 17(int) Load 312(i16) + 436: 435(ivec4) CompositeConstruct 434 434 434 434 + 437: 274(int) Bitcast 436 + Store 433(packi64) 437 + 438: 274(int) Load 433(packi64) + 439: 435(ivec4) Bitcast 438 + 440: 188(ivec2) VectorShuffle 439 439 0 1 + Store 306(i16v) 440 + 443: 14(int) Load 322(u16) + 445: 444(ivec4) CompositeConstruct 443 443 443 443 + 446: 286(int) Bitcast 445 + Store 442(packu64) 446 + 447: 286(int) Load 442(packu64) + 448: 444(ivec4) Bitcast 447 + 449: 49(ivec3) VectorShuffle 448 448 0 1 2 + Store 320(u16v) 449 + 452: 49(ivec3) Load 320(u16v) + 453: 14(int) Load 322(u16) + 454: 49(ivec3) CompositeConstruct 453 453 453 + 455: 389(bvec3) ULessThan 452 454 + Store 451(bv) 455 + 456: 188(ivec2) Load 306(i16v) + 457: 17(int) Load 312(i16) + 458: 188(ivec2) CompositeConstruct 457 457 + 459: 191(bvec2) SLessThan 456 458 + 460: 389(bvec3) Load 451(bv) + 461: 389(bvec3) VectorShuffle 460 459 3 4 2 + Store 451(bv) 461 + 462: 49(ivec3) Load 320(u16v) + 463: 14(int) Load 322(u16) + 464: 49(ivec3) CompositeConstruct 463 463 463 + 465: 389(bvec3) ULessThanEqual 462 464 + Store 451(bv) 465 + 466: 188(ivec2) Load 306(i16v) + 467: 17(int) Load 312(i16) + 468: 188(ivec2) CompositeConstruct 467 467 + 469: 191(bvec2) SLessThanEqual 466 468 + 470: 389(bvec3) Load 451(bv) + 471: 389(bvec3) VectorShuffle 470 469 3 4 2 + Store 451(bv) 471 + 472: 49(ivec3) Load 320(u16v) + 473: 14(int) Load 322(u16) + 474: 49(ivec3) CompositeConstruct 473 473 473 + 475: 389(bvec3) UGreaterThan 472 474 + Store 451(bv) 475 + 476: 188(ivec2) Load 306(i16v) + 477: 17(int) Load 312(i16) + 478: 188(ivec2) CompositeConstruct 477 477 + 479: 191(bvec2) SGreaterThan 476 478 + 480: 389(bvec3) Load 451(bv) + 481: 389(bvec3) VectorShuffle 480 479 3 4 2 + Store 451(bv) 481 + 482: 49(ivec3) Load 320(u16v) + 483: 14(int) Load 322(u16) + 484: 49(ivec3) CompositeConstruct 483 483 483 + 485: 389(bvec3) UGreaterThanEqual 482 484 + Store 451(bv) 485 + 486: 188(ivec2) Load 306(i16v) + 487: 17(int) Load 312(i16) + 488: 188(ivec2) CompositeConstruct 487 487 + 489: 191(bvec2) SGreaterThanEqual 486 488 + 490: 389(bvec3) Load 451(bv) + 491: 389(bvec3) VectorShuffle 490 489 3 4 2 + Store 451(bv) 491 + 492: 49(ivec3) Load 320(u16v) + 493: 14(int) Load 322(u16) + 494: 49(ivec3) CompositeConstruct 493 493 493 + 495: 389(bvec3) IEqual 492 494 + Store 451(bv) 495 + 496: 188(ivec2) Load 306(i16v) + 497: 17(int) Load 312(i16) + 498: 188(ivec2) CompositeConstruct 497 497 + 499: 191(bvec2) IEqual 496 498 + 500: 389(bvec3) Load 451(bv) + 501: 389(bvec3) VectorShuffle 500 499 3 4 2 + Store 451(bv) 501 + 502: 49(ivec3) Load 320(u16v) + 503: 14(int) Load 322(u16) + 504: 49(ivec3) CompositeConstruct 503 503 503 + 505: 389(bvec3) INotEqual 502 504 + Store 451(bv) 505 + 506: 188(ivec2) Load 306(i16v) + 507: 17(int) Load 312(i16) + 508: 188(ivec2) CompositeConstruct 507 507 + 509: 191(bvec2) INotEqual 506 508 + 510: 389(bvec3) Load 451(bv) + 511: 389(bvec3) VectorShuffle 510 509 3 4 2 + Store 451(bv) 511 + Return + FunctionEnd diff --git a/Test/spv.int16.frag b/Test/spv.int16.frag new file mode 100644 index 00000000..9dd9090c --- /dev/null +++ b/Test/spv.int16.frag @@ -0,0 +1,314 @@ +#version 450 core + +#extension GL_ARB_gpu_shader_int64: enable +#extension GL_AMD_gpu_shader_half_float: enable +#extension GL_AMD_gpu_shader_int16: enable + +layout(binding = 0) uniform Uniforms +{ + uint i; +}; + +// int16/uint16 in block +layout(std140, binding = 1) uniform Block +{ + i16vec3 i16v; + uint16_t u16; +} block; + +// int16/uint16 for input +layout(location = 0) in flat u16vec3 iu16v; +layout(location = 1) in flat int16_t ii16; + +void literal() +{ + const int16_t i16c[3] = + { + 0x111S, // Hex + -2s, // Dec + 0400s, // Oct + }; + + const uint16_t u16c[] = + { + 0xFFFFus, // Hex + 65535US, // Dec + 0177777us, // Oct + }; + + uint16_t u16 = i16c[i] + u16c[i]; +} + +void operators() +{ + u16vec3 u16v; + int16_t i16; + uint16_t u16; + int i; + uint u; + bool b; + + // Unary + u16v++; + i16--; + ++i16; + --u16v; + + u16v = ~u16v; + + i16 = +i16; + u16v = -u16v; + + // Arithmetic + u16 += i16; + u16v -= u16v; + i16 *= i16; + u16v /= u16v; + u16v %= i16; + + u16v = u16v + u16v; + u16 = i16 - u16; + u16v = u16v * i16; + i16 = i16 * i16; + i16 = i16 % i16; + + // Shift + u16v <<= i; + i16 >>= u16v.y; + + i16 = i16 << u16v.z; + u16v = u16v << i16; + + // Relational + b = (u16v.x != i16); + b = (i16 == u16v.x); + b = (u16v.x > u16v.y); + b = (i16 < u); + b = (u16v.y >= u16v.x); + b = (i16 <= i); + + // Bitwise + u16v |= i16; + u16 = i16 | u16; + i16 &= i16; + u16v = u16v & u16v; + u16v ^= i16; + u16v = u16v ^ i16; +} + +void typeCast() +{ + bvec2 bv; + ivec2 iv; + uvec2 uv; + vec2 fv; + dvec2 dv; + + f16vec2 f16v; + i64vec2 i64v; + u64vec2 u64v; + i16vec2 i16v; + u16vec2 u16v; + + i16v = i16vec2(bv); // bool -> int16 + u16v = u16vec2(bv); // bool -> uint16 + bv = bvec2(i16v); // int16 -> bool + bv = bvec2(u16v); // uint16 -> bool + + i16v = i16vec2(iv); // int -> int16 + u16v = u16vec2(iv); // int -> uint16 + iv = i16v; // int16 -> int + iv = ivec2(u16v); // uint16 -> int + + i16v = i16vec2(uv); // uint -> int16 + u16v = u16vec2(uv); // uint -> uint16 + uv = i16v; // int16 -> uint + uv = u16v; // uint16 -> uint + + i16v = i16vec2(fv); // float -> int16 + u16v = u16vec2(fv); // float -> uint16 + fv = i16v; // int16 -> float + fv = u16v; // uint16 -> float + + i16v = i16vec2(dv); // double -> int16 + u16v = u16vec2(dv); // double -> uint16 + dv = i16v; // int16 -> double + dv = u16v; // uint16 -> double + + i16v = i16vec2(f16v); // float16 -> int16 + u16v = u16vec2(f16v); // float16 -> uint16 + f16v = i16v; // int16 -> float16 + f16v = u16v; // uint16 -> float16 + + i16v = i16vec2(i64v); // int64 -> int16 + u16v = u16vec2(i64v); // int64 -> uint16 + i64v = i16v; // int16 -> int64 + i64v = i64vec2(u16v); // uint16 -> int64 + + i16v = i16vec2(u64v); // uint64 -> int16 + u16v = u16vec2(u64v); // uint64 -> uint16 + u64v = i16v; // int16 -> uint64 + u64v = u16v; // uint16 -> uint64 + + i16v = i16vec2(u16v); // uint16 -> int16 + u16v = i16v; // int16 -> uint16 +} + +void builtinFuncs() +{ + i16vec2 i16v; + u16vec3 u16v; + f16vec3 f16v; + bvec3 bv; + + int16_t i16; + uint16_t u16; + + // abs() + i16v = abs(i16v); + + // sign() + i16v = sign(i16v); + + // min() + i16v = min(i16v, i16); + i16v = min(i16v, i16vec2(-1s)); + u16v = min(u16v, u16); + u16v = min(u16v, u16vec3(0us)); + + // max() + i16v = max(i16v, i16); + i16v = max(i16v, i16vec2(-1s)); + u16v = max(u16v, u16); + u16v = max(u16v, u16vec3(0us)); + + // clamp() + i16v = clamp(i16v, -i16, i16); + i16v = clamp(i16v, -i16v, i16v); + u16v = clamp(u16v, -u16, u16); + u16v = clamp(u16v, -u16v, u16v); + + // mix() + i16 = mix(i16v.x, i16v.y, true); + i16v = mix(i16vec2(i16), i16vec2(-i16), bvec2(false)); + u16 = mix(u16v.x, u16v.y, true); + u16v = mix(u16vec3(u16), u16vec3(-u16), bvec3(false)); + + // frexp() + i16vec3 exp; + f16v = frexp(f16v, exp); + + // ldexp() + f16v = ldexp(f16v, exp); + + // float16BitsToInt16() + i16v = float16BitsToInt16(f16v.xy); + + // float16BitsToUint16() + u16v.x = float16BitsToUint16(f16v.z); + + // int16BitsToFloat16() + f16v.xy = int16BitsToFloat16(i16v); + + // uint16BitsToFloat16() + f16v = uint16BitsToFloat16(u16v); + + // packInt2x16() + int packi = packInt2x16(i16v); + + // unpackInt2x16() + i16v = unpackInt2x16(packi); + + // packUint2x16() + uint packu = packUint2x16(u16v.xy); + + // unpackUint2x16() + u16v.xy = unpackUint2x16(packu); + + // packInt4x16() + int64_t packi64 = packInt4x16(i16vec4(i16)); + + // unpackInt4x16() + i16v = unpackInt4x16(packi64).xy; + + // packUint4x16() + uint64_t packu64 = packUint4x16(u16vec4(u16)); + + // unpackUint4x16() + u16v = unpackUint4x16(packu64).xyz; + + // lessThan() + bv = lessThan(u16v, u16vec3(u16)); + bv.xy = lessThan(i16v, i16vec2(i16)); + + // lessThanEqual() + bv = lessThanEqual(u16v, u16vec3(u16)); + bv.xy = lessThanEqual(i16v, i16vec2(i16)); + + // greaterThan() + bv = greaterThan(u16v, u16vec3(u16)); + bv.xy = greaterThan(i16v, i16vec2(i16)); + + // greaterThanEqual() + bv = greaterThanEqual(u16v, u16vec3(u16)); + bv.xy = greaterThanEqual(i16v, i16vec2(i16)); + + // equal() + bv = equal(u16v, u16vec3(u16)); + bv.xy = equal(i16v, i16vec2(i16)); + + // notEqual() + bv = notEqual(u16v, u16vec3(u16)); + bv.xy = notEqual(i16v, i16vec2(i16)); +} + +// Type conversion for specialization constant +layout(constant_id = 100) const int64_t si64 = -10L; +layout(constant_id = 101) const uint64_t su64 = 20UL; +layout(constant_id = 102) const int si = -5; +layout(constant_id = 103) const uint su = 4; +layout(constant_id = 104) const bool sb = true; +layout(constant_id = 105) const int16_t si16 = -5S; +layout(constant_id = 106) const uint16_t su16 = 4US; + +// bool <-> int16/uint16 +const bool i16_to_b = bool(si16); +const bool u16_to_b = bool(su16); +const int16_t b_to_i16 = int16_t(sb); +const uint16_t b_to_u16 = uint16_t(sb); + +// int <-> int16/uint16 +const int i16_to_i = int(si16); +const int u16_to_i = int(su16); +const int16_t i_to_i16 = int16_t(si); +const uint16_t i_to_u16 = uint16_t(si); + +// uint <-> int16/uint16 +const uint i16_to_u = uint(si16); +const uint u16_to_u = uint(su16); +const int16_t u_to_i16 = int16_t(su); +const uint16_t u_to_u16 = uint16_t(su); + +// int64 <-> int16/uint16 +const int64_t i16_to_i64 = int64_t(si16); +const int64_t u16_to_i64 = int64_t(su16); +const int16_t i64_to_i16 = int16_t(si64); +const uint16_t i64_to_u16 = uint16_t(si64); + +// uint64 <-> int16/uint16 +const uint64_t i16_to_u64 = uint64_t(si16); +const uint64_t u16_to_u64 = uint64_t(su16); +const int16_t u64_to_i16 = int16_t(su64); +const uint16_t u64_to_u16 = uint16_t(su64); + +// int16 <-> uint16 +const uint16_t i16_to_u16 = uint16_t(si16); +const int16_t u16_to_i16 = int16_t(su16); + +void main() +{ + literal(); + operators(); + typeCast(); + builtinFuncs(); +} diff --git a/glslang/Include/BaseTypes.h b/glslang/Include/BaseTypes.h index abac5122..46392d05 100644 --- a/glslang/Include/BaseTypes.h +++ b/glslang/Include/BaseTypes.h @@ -53,6 +53,10 @@ enum TBasicType { EbtUint, EbtInt64, EbtUint64, +#ifdef AMD_EXTENSIONS + EbtInt16, + EbtUint16, +#endif EbtBool, EbtAtomicUint, EbtSampler, diff --git a/glslang/Include/Types.h b/glslang/Include/Types.h index fe4cccee..16d89320 100644 --- a/glslang/Include/Types.h +++ b/glslang/Include/Types.h @@ -190,8 +190,6 @@ struct TSampler { // misnomer now; includes images, textures without sampler, case EbtFloat: break; case EbtInt: s.append("i"); break; case EbtUint: s.append("u"); break; - case EbtInt64: s.append("i64"); break; - case EbtUint64: s.append("u64"); break; default: break; // some compilers want this } if (image) { @@ -1448,6 +1446,10 @@ public: case EbtUint: case EbtInt64: case EbtUint64: +#ifdef AMD_EXTENSIONS + case EbtInt16: + case EbtUint16: +#endif case EbtBool: return true; default: @@ -1531,6 +1533,10 @@ public: case EbtUint: return "uint"; case EbtInt64: return "int64_t"; case EbtUint64: return "uint64_t"; +#ifdef AMD_EXTENSIONS + case EbtInt16: return "int16_t"; + case EbtUint16: return "uint16_t"; +#endif case EbtBool: return "bool"; case EbtAtomicUint: return "atomic_uint"; case EbtSampler: return "sampler/image"; diff --git a/glslang/Include/intermediate.h b/glslang/Include/intermediate.h index 9618a992..98cc5546 100644 --- a/glslang/Include/intermediate.h +++ b/glslang/Include/intermediate.h @@ -141,6 +141,42 @@ enum TOperator { EOpConvFloat16ToDouble, EOpConvFloat16ToInt64, EOpConvFloat16ToUint64, + + EOpConvBoolToInt16, + EOpConvIntToInt16, + EOpConvUintToInt16, + EOpConvFloatToInt16, + EOpConvDoubleToInt16, + EOpConvFloat16ToInt16, + EOpConvInt64ToInt16, + EOpConvUint64ToInt16, + EOpConvUint16ToInt16, + EOpConvInt16ToBool, + EOpConvInt16ToInt, + EOpConvInt16ToUint, + EOpConvInt16ToFloat, + EOpConvInt16ToDouble, + EOpConvInt16ToFloat16, + EOpConvInt16ToInt64, + EOpConvInt16ToUint64, + + EOpConvBoolToUint16, + EOpConvIntToUint16, + EOpConvUintToUint16, + EOpConvFloatToUint16, + EOpConvDoubleToUint16, + EOpConvFloat16ToUint16, + EOpConvInt64ToUint16, + EOpConvUint64ToUint16, + EOpConvInt16ToUint16, + EOpConvUint16ToBool, + EOpConvUint16ToInt, + EOpConvUint16ToUint, + EOpConvUint16ToFloat, + EOpConvUint16ToDouble, + EOpConvUint16ToFloat16, + EOpConvUint16ToInt64, + EOpConvUint16ToUint64, #endif // @@ -244,6 +280,12 @@ enum TOperator { EOpDoubleBitsToUint64, EOpInt64BitsToDouble, EOpUint64BitsToDouble, +#ifdef AMD_EXTENSIONS + EOpFloat16BitsToInt16, + EOpFloat16BitsToUint16, + EOpInt16BitsToFloat16, + EOpUint16BitsToFloat16, +#endif EOpPackSnorm2x16, EOpUnpackSnorm2x16, EOpPackUnorm2x16, @@ -263,6 +305,14 @@ enum TOperator { #ifdef AMD_EXTENSIONS EOpPackFloat2x16, EOpUnpackFloat2x16, + EOpPackInt2x16, + EOpUnpackInt2x16, + EOpPackUint2x16, + EOpUnpackUint2x16, + EOpPackInt4x16, + EOpUnpackInt4x16, + EOpPackUint4x16, + EOpUnpackUint4x16, #endif EOpLength, @@ -394,15 +444,27 @@ enum TOperator { EOpConstructUint, EOpConstructInt64, EOpConstructUint64, +#ifdef AMD_EXTENSIONS + EOpConstructInt16, + EOpConstructUint16, +#endif EOpConstructBool, EOpConstructFloat, EOpConstructDouble, +#ifdef AMD_EXTENSIONS + EOpConstructFloat16, +#endif EOpConstructVec2, EOpConstructVec3, EOpConstructVec4, EOpConstructDVec2, EOpConstructDVec3, EOpConstructDVec4, +#ifdef AMD_EXTENSIONS + EOpConstructF16Vec2, + EOpConstructF16Vec3, + EOpConstructF16Vec4, +#endif EOpConstructBVec2, EOpConstructBVec3, EOpConstructBVec4, @@ -418,6 +480,14 @@ enum TOperator { EOpConstructU64Vec2, EOpConstructU64Vec3, EOpConstructU64Vec4, +#ifdef AMD_EXTENSIONS + EOpConstructI16Vec2, + EOpConstructI16Vec3, + EOpConstructI16Vec4, + EOpConstructU16Vec2, + EOpConstructU16Vec3, + EOpConstructU16Vec4, +#endif EOpConstructMat2x2, EOpConstructMat2x3, EOpConstructMat2x4, @@ -464,10 +534,6 @@ enum TOperator { EOpConstructBMat4x3, EOpConstructBMat4x4, #ifdef AMD_EXTENSIONS - EOpConstructFloat16, - EOpConstructF16Vec2, - EOpConstructF16Vec3, - EOpConstructF16Vec4, EOpConstructF16Mat2x2, EOpConstructF16Mat2x3, EOpConstructF16Mat2x4, diff --git a/glslang/MachineIndependent/Constant.cpp b/glslang/MachineIndependent/Constant.cpp index fff8fd26..625b8e94 100644 --- a/glslang/MachineIndependent/Constant.cpp +++ b/glslang/MachineIndependent/Constant.cpp @@ -193,7 +193,7 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TIntermTyped* right case EbtUint: if (rightUnionArray[i] == 0) { - newConstArray[i].setUConst(0xFFFFFFFF); + newConstArray[i].setUConst(0xFFFFFFFFu); } else newConstArray[i].setUConst(leftUnionArray[i].getUConst() / rightUnionArray[i].getUConst()); break; @@ -213,6 +213,23 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TIntermTyped* right } else newConstArray[i].setU64Const(leftUnionArray[i].getU64Const() / rightUnionArray[i].getU64Const()); break; +#ifdef AMD_EXTENSIONS + case EbtInt16: + if (rightUnionArray[i] == 0) + newConstArray[i].setIConst(0x7FFF); + else if (rightUnionArray[i].getIConst() == -1 && leftUnionArray[i].getIConst() == (int)0x8000) + newConstArray[i].setIConst(0x8000); + else + newConstArray[i].setIConst(leftUnionArray[i].getIConst() / rightUnionArray[i].getIConst()); + break; + + case EbtUint16: + if (rightUnionArray[i] == 0) { + newConstArray[i].setUConst(0xFFFFu); + } else + newConstArray[i].setUConst(leftUnionArray[i].getUConst() / rightUnionArray[i].getUConst()); + break; +#endif default: return 0; } @@ -457,10 +474,16 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType) case EbtFloat16: #endif case EbtFloat: newConstArray[i].setDConst(-unionArray[i].getDConst()); break; +#ifdef AMD_EXTENSIONS + case EbtInt16: +#endif case EbtInt: newConstArray[i].setIConst(-unionArray[i].getIConst()); break; +#ifdef AMD_EXTENSIONS + case EbtUint16: +#endif case EbtUint: newConstArray[i].setUConst(static_cast(-static_cast(unionArray[i].getUConst()))); break; case EbtInt64: newConstArray[i].setI64Const(-unionArray[i].getI64Const()); break; - case EbtUint64: newConstArray[i].setU64Const(static_cast(-static_cast(unionArray[i].getU64Const()))); break; + case EbtUint64: newConstArray[i].setU64Const(static_cast(-static_cast(unionArray[i].getU64Const()))); break; default: return 0; } @@ -610,6 +633,14 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType) case EOpUintBitsToFloat: case EOpDoubleBitsToInt64: case EOpDoubleBitsToUint64: + case EOpInt64BitsToDouble: + case EOpUint64BitsToDouble: +#ifdef AMD_EXTENSIONS + case EOpFloat16BitsToInt16: + case EOpFloat16BitsToUint16: + case EOpInt16BitsToFloat16: + case EOpUint16BitsToFloat16: +#endif default: return 0; @@ -702,6 +733,9 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode) #endif children[0]->getAsTyped()->getBasicType() == EbtDouble; bool isSigned = children[0]->getAsTyped()->getBasicType() == EbtInt || +#ifdef AMD_EXTENSIONS + children[0]->getAsTyped()->getBasicType() == EbtInt16 || +#endif children[0]->getAsTyped()->getBasicType() == EbtInt64; bool isInt64 = children[0]->getAsTyped()->getBasicType() == EbtInt64 || children[0]->getAsTyped()->getBasicType() == EbtUint64; diff --git a/glslang/MachineIndependent/Initialize.cpp b/glslang/MachineIndependent/Initialize.cpp index 083b3cef..b1e510b5 100644 --- a/glslang/MachineIndependent/Initialize.cpp +++ b/glslang/MachineIndependent/Initialize.cpp @@ -85,8 +85,6 @@ TBuiltIns::TBuiltIns() prefixes[EbtFloat] = ""; prefixes[EbtInt] = "i"; prefixes[EbtUint] = "u"; - prefixes[EbtInt64] = "i64"; - prefixes[EbtUint64] = "u64"; postfixes[2] = "2"; postfixes[3] = "3"; postfixes[4] = "4"; @@ -2612,6 +2610,157 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV "\n"); } + + // GL_AMD_gpu_shader_int16 + if (profile != EEsProfile && version >= 450) { + commonBuiltins.append( + "int16_t abs(int16_t);" + "i16vec2 abs(i16vec2);" + "i16vec3 abs(i16vec3);" + "i16vec4 abs(i16vec4);" + + "int16_t sign(int16_t);" + "i16vec2 sign(i16vec2);" + "i16vec3 sign(i16vec3);" + "i16vec4 sign(i16vec4);" + + "int16_t min(int16_t, int16_t);" + "i16vec2 min(i16vec2, int16_t);" + "i16vec3 min(i16vec3, int16_t);" + "i16vec4 min(i16vec4, int16_t);" + "i16vec2 min(i16vec2, i16vec2);" + "i16vec3 min(i16vec3, i16vec3);" + "i16vec4 min(i16vec4, i16vec4);" + "uint16_t min(uint16_t, uint16_t);" + "u16vec2 min(u16vec2, uint16_t);" + "u16vec3 min(u16vec3, uint16_t);" + "u16vec4 min(u16vec4, uint16_t);" + "u16vec2 min(u16vec2, u16vec2);" + "u16vec3 min(u16vec3, u16vec3);" + "u16vec4 min(u16vec4, u16vec4);" + + "int16_t max(int16_t, int16_t);" + "i16vec2 max(i16vec2, int16_t);" + "i16vec3 max(i16vec3, int16_t);" + "i16vec4 max(i16vec4, int16_t);" + "i16vec2 max(i16vec2, i16vec2);" + "i16vec3 max(i16vec3, i16vec3);" + "i16vec4 max(i16vec4, i16vec4);" + "uint16_t max(uint16_t, uint16_t);" + "u16vec2 max(u16vec2, uint16_t);" + "u16vec3 max(u16vec3, uint16_t);" + "u16vec4 max(u16vec4, uint16_t);" + "u16vec2 max(u16vec2, u16vec2);" + "u16vec3 max(u16vec3, u16vec3);" + "u16vec4 max(u16vec4, u16vec4);" + + "int16_t clamp(int16_t, int16_t, int16_t);" + "i16vec2 clamp(i16vec2, int16_t, int16_t);" + "i16vec3 clamp(i16vec3, int16_t, int16_t);" + "i16vec4 clamp(i16vec4, int16_t, int16_t);" + "i16vec2 clamp(i16vec2, i16vec2, i16vec2);" + "i16vec3 clamp(i16vec3, i16vec3, i16vec3);" + "i16vec4 clamp(i16vec4, i16vec4, i16vec4);" + "uint16_t clamp(uint16_t, uint16_t, uint16_t);" + "u16vec2 clamp(u16vec2, uint16_t, uint16_t);" + "u16vec3 clamp(u16vec3, uint16_t, uint16_t);" + "u16vec4 clamp(u16vec4, uint16_t, uint16_t);" + "u16vec2 clamp(u16vec2, u16vec2, u16vec2);" + "u16vec3 clamp(u16vec3, u16vec3, u16vec3);" + "u16vec4 clamp(u16vec4, u16vec4, u16vec4);" + + "int16_t mix(int16_t, int16_t, bool);" + "i16vec2 mix(i16vec2, i16vec2, bvec2);" + "i16vec3 mix(i16vec3, i16vec3, bvec3);" + "i16vec4 mix(i16vec4, i16vec4, bvec4);" + "uint16_t mix(uint16_t, uint16_t, bool);" + "u16vec2 mix(u16vec2, u16vec2, bvec2);" + "u16vec3 mix(u16vec3, u16vec3, bvec3);" + "u16vec4 mix(u16vec4, u16vec4, bvec4);" + + "float16_t frexp(float16_t, out int16_t);" + "f16vec2 frexp(f16vec2, out i16vec2);" + "f16vec3 frexp(f16vec3, out i16vec3);" + "f16vec4 frexp(f16vec4, out i16vec4);" + + "float16_t ldexp(float16_t, int16_t);" + "f16vec2 ldexp(f16vec2, i16vec2);" + "f16vec3 ldexp(f16vec3, i16vec3);" + "f16vec4 ldexp(f16vec4, i16vec4);" + + "int16_t float16BitsToInt16(float16_t);" + "i16vec2 float16BitsToInt16(f16vec2);" + "i16vec3 float16BitsToInt16(f16vec3);" + "i16vec4 float16BitsToInt16(f16vec4);" + + "uint16_t float16BitsToUint16(float16_t);" + "u16vec2 float16BitsToUint16(f16vec2);" + "u16vec3 float16BitsToUint16(f16vec3);" + "u16vec4 float16BitsToUint16(f16vec4);" + + "float16_t int16BitsToFloat16(int16_t);" + "f16vec2 int16BitsToFloat16(i16vec2);" + "f16vec3 int16BitsToFloat16(i16vec3);" + "f16vec4 int16BitsToFloat16(i16vec4);" + + "float16_t uint16BitsToFloat16(uint16_t);" + "f16vec2 uint16BitsToFloat16(u16vec2);" + "f16vec3 uint16BitsToFloat16(u16vec3);" + "f16vec4 uint16BitsToFloat16(u16vec4);" + + "int packInt2x16(i16vec2);" + "uint packUint2x16(u16vec2);" + "int64_t packInt4x16(i16vec4);" + "uint64_t packUint4x16(u16vec4);" + "i16vec2 unpackInt2x16(int);" + "u16vec2 unpackUint2x16(uint);" + "i16vec4 unpackInt4x16(int64_t);" + "u16vec4 unpackUint4x16(uint64_t);" + + "bvec2 lessThan(i16vec2, i16vec2);" + "bvec3 lessThan(i16vec3, i16vec3);" + "bvec4 lessThan(i16vec4, i16vec4);" + "bvec2 lessThan(u16vec2, u16vec2);" + "bvec3 lessThan(u16vec3, u16vec3);" + "bvec4 lessThan(u16vec4, u16vec4);" + + "bvec2 lessThanEqual(i16vec2, i16vec2);" + "bvec3 lessThanEqual(i16vec3, i16vec3);" + "bvec4 lessThanEqual(i16vec4, i16vec4);" + "bvec2 lessThanEqual(u16vec2, u16vec2);" + "bvec3 lessThanEqual(u16vec3, u16vec3);" + "bvec4 lessThanEqual(u16vec4, u16vec4);" + + "bvec2 greaterThan(i16vec2, i16vec2);" + "bvec3 greaterThan(i16vec3, i16vec3);" + "bvec4 greaterThan(i16vec4, i16vec4);" + "bvec2 greaterThan(u16vec2, u16vec2);" + "bvec3 greaterThan(u16vec3, u16vec3);" + "bvec4 greaterThan(u16vec4, u16vec4);" + + "bvec2 greaterThanEqual(i16vec2, i16vec2);" + "bvec3 greaterThanEqual(i16vec3, i16vec3);" + "bvec4 greaterThanEqual(i16vec4, i16vec4);" + "bvec2 greaterThanEqual(u16vec2, u16vec2);" + "bvec3 greaterThanEqual(u16vec3, u16vec3);" + "bvec4 greaterThanEqual(u16vec4, u16vec4);" + + "bvec2 equal(i16vec2, i16vec2);" + "bvec3 equal(i16vec3, i16vec3);" + "bvec4 equal(i16vec4, i16vec4);" + "bvec2 equal(u16vec2, u16vec2);" + "bvec3 equal(u16vec3, u16vec3);" + "bvec4 equal(u16vec4, u16vec4);" + + "bvec2 notEqual(i16vec2, i16vec2);" + "bvec3 notEqual(i16vec3, i16vec3);" + "bvec4 notEqual(i16vec4, i16vec4);" + "bvec2 notEqual(u16vec2, u16vec2);" + "bvec3 notEqual(u16vec3, u16vec3);" + "bvec4 notEqual(u16vec4, u16vec4);" + + "\n"); + } #endif //============================================================================ @@ -5639,6 +5788,12 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.relateToOperator("doubleBitsToUint64", EOpDoubleBitsToUint64); symbolTable.relateToOperator("int64BitsToDouble", EOpInt64BitsToDouble); symbolTable.relateToOperator("uint64BitsToDouble", EOpUint64BitsToDouble); +#ifdef AMD_EXTENSIONS + symbolTable.relateToOperator("float16BitsToInt16", EOpFloat16BitsToInt16); + symbolTable.relateToOperator("float16BitsToUint16", EOpFloat16BitsToUint16); + symbolTable.relateToOperator("int16BitsToFloat16", EOpInt16BitsToFloat16); + symbolTable.relateToOperator("uint16BitsToFloat16", EOpUint16BitsToFloat16); +#endif symbolTable.relateToOperator("packSnorm2x16", EOpPackSnorm2x16); symbolTable.relateToOperator("unpackSnorm2x16", EOpUnpackSnorm2x16); @@ -5662,6 +5817,16 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.relateToOperator("unpackUint2x32", EOpUnpackUint2x32); #ifdef AMD_EXTENSIONS + symbolTable.relateToOperator("packInt2x16", EOpPackInt2x16); + symbolTable.relateToOperator("unpackInt2x16", EOpUnpackInt2x16); + symbolTable.relateToOperator("packUint2x16", EOpPackUint2x16); + symbolTable.relateToOperator("unpackUint2x16", EOpUnpackUint2x16); + + symbolTable.relateToOperator("packInt4x16", EOpPackInt4x16); + symbolTable.relateToOperator("unpackInt4x16", EOpUnpackInt4x16); + symbolTable.relateToOperator("packUint4x16", EOpPackUint4x16); + symbolTable.relateToOperator("unpackUint4x16", EOpUnpackUint4x16); + symbolTable.relateToOperator("packFloat2x16", EOpPackFloat2x16); symbolTable.relateToOperator("unpackFloat2x16", EOpUnpackFloat2x16); #endif diff --git a/glslang/MachineIndependent/Intermediate.cpp b/glslang/MachineIndependent/Intermediate.cpp index 29a0e741..c07dab9d 100644 --- a/glslang/MachineIndependent/Intermediate.cpp +++ b/glslang/MachineIndependent/Intermediate.cpp @@ -308,6 +308,10 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child, TSo case EOpConstructUint: newType = EbtUint; break; case EOpConstructInt64: newType = EbtInt64; break; case EOpConstructUint64: newType = EbtUint64; break; +#ifdef AMD_EXTENSIONS + case EOpConstructInt16: newType = EbtInt16; break; + case EOpConstructUint16: newType = EbtUint16; break; +#endif case EOpConstructBool: newType = EbtBool; break; case EOpConstructFloat: newType = EbtFloat; break; case EOpConstructDouble: newType = EbtDouble; break; @@ -336,6 +340,10 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child, TSo case EOpConstructUint: case EOpConstructInt64: case EOpConstructUint64: +#ifdef AMD_EXTENSIONS + case EOpConstructInt16: + case EOpConstructUint16: +#endif case EOpConstructBool: case EOpConstructFloat: case EOpConstructDouble: @@ -528,6 +536,14 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EOpConstructUint64: promoteTo = EbtUint64; break; +#ifdef AMD_EXTENSIONS + case EOpConstructInt16: + promoteTo = EbtInt16; + break; + case EOpConstructUint16: + promoteTo = EbtUint16; + break; +#endif // // List all the binary ops that can implicitly convert one operand to the other's type; @@ -616,10 +632,18 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EOpRightShiftAssign: if ((type.getBasicType() == EbtInt || type.getBasicType() == EbtUint || +#ifdef AMD_EXTENSIONS + type.getBasicType() == EbtInt16 || + type.getBasicType() == EbtUint16 || +#endif type.getBasicType() == EbtInt64 || type.getBasicType() == EbtUint64) && (node->getType().getBasicType() == EbtInt || node->getType().getBasicType() == EbtUint || +#ifdef AMD_EXTENSIONS + node->getType().getBasicType() == EbtInt16 || + node->getType().getBasicType() == EbtUint16 || +#endif node->getType().getBasicType() == EbtInt64 || node->getType().getBasicType() == EbtUint64)) @@ -663,6 +687,10 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt #endif case EbtInt64: newOp = EOpConvInt64ToDouble; break; case EbtUint64: newOp = EOpConvUint64ToDouble; break; +#ifdef AMD_EXTENSIONS + case EbtInt16: newOp = EOpConvInt16ToDouble; break; + case EbtUint16: newOp = EOpConvUint16ToDouble; break; +#endif default: return nullptr; } @@ -678,6 +706,10 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt #endif case EbtInt64: newOp = EOpConvInt64ToFloat; break; case EbtUint64: newOp = EOpConvUint64ToFloat; break; +#ifdef AMD_EXTENSIONS + case EbtInt16: newOp = EOpConvInt16ToFloat; break; + case EbtUint16: newOp = EOpConvUint16ToFloat; break; +#endif default: return nullptr; } @@ -692,6 +724,8 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EbtDouble: newOp = EOpConvDoubleToFloat16; break; case EbtInt64: newOp = EOpConvInt64ToFloat16; break; case EbtUint64: newOp = EOpConvUint64ToFloat16; break; + case EbtInt16: newOp = EOpConvInt16ToFloat16; break; + case EbtUint16: newOp = EOpConvUint16ToFloat16; break; default: return nullptr; } @@ -708,6 +742,10 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt #endif case EbtInt64: newOp = EOpConvInt64ToBool; break; case EbtUint64: newOp = EOpConvUint64ToBool; break; +#ifdef AMD_EXTENSIONS + case EbtInt16: newOp = EOpConvInt16ToBool; break; + case EbtUint16: newOp = EOpConvUint16ToBool; break; +#endif default: return nullptr; } @@ -723,6 +761,10 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt #endif case EbtInt64: newOp = EOpConvInt64ToInt; break; case EbtUint64: newOp = EOpConvUint64ToInt; break; +#ifdef AMD_EXTENSIONS + case EbtInt16: newOp = EOpConvInt16ToInt; break; + case EbtUint16: newOp = EOpConvUint16ToInt; break; +#endif default: return nullptr; } @@ -738,6 +780,10 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt #endif case EbtInt64: newOp = EOpConvInt64ToUint; break; case EbtUint64: newOp = EOpConvUint64ToUint; break; +#ifdef AMD_EXTENSIONS + case EbtInt16: newOp = EOpConvInt16ToUint; break; + case EbtUint16: newOp = EOpConvUint16ToUint; break; +#endif default: return nullptr; } @@ -753,6 +799,10 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EbtFloat16: newOp = EOpConvFloat16ToInt64; break; #endif case EbtUint64: newOp = EOpConvUint64ToInt64; break; +#ifdef AMD_EXTENSIONS + case EbtInt16: newOp = EOpConvInt16ToInt64; break; + case EbtUint16: newOp = EOpConvUint16ToInt64; break; +#endif default: return nullptr; } @@ -768,10 +818,46 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EbtFloat16: newOp = EOpConvFloat16ToUint64; break; #endif case EbtInt64: newOp = EOpConvInt64ToUint64; break; +#ifdef AMD_EXTENSIONS + case EbtInt16: newOp = EOpConvInt16ToUint64; break; + case EbtUint16: newOp = EOpConvUint16ToUint64; break; +#endif default: return nullptr; } break; +#ifdef AMD_EXTENSIONS + case EbtInt16: + switch (node->getBasicType()) { + case EbtInt: newOp = EOpConvIntToInt16; break; + case EbtUint: newOp = EOpConvUintToInt16; break; + case EbtBool: newOp = EOpConvBoolToInt16; break; + case EbtFloat: newOp = EOpConvFloatToInt16; break; + case EbtDouble: newOp = EOpConvDoubleToInt16; break; + case EbtFloat16: newOp = EOpConvFloat16ToInt16; break; + case EbtInt64: newOp = EOpConvInt64ToInt16; break; + case EbtUint64: newOp = EOpConvUint64ToInt16; break; + case EbtUint16: newOp = EOpConvUint16ToInt16; break; + default: + return nullptr; + } + break; + case EbtUint16: + switch (node->getBasicType()) { + case EbtInt: newOp = EOpConvIntToUint16; break; + case EbtUint: newOp = EOpConvUintToUint16; break; + case EbtBool: newOp = EOpConvBoolToUint16; break; + case EbtFloat: newOp = EOpConvFloatToUint16; break; + case EbtDouble: newOp = EOpConvDoubleToUint16; break; + case EbtFloat16: newOp = EOpConvFloat16ToUint16; break; + case EbtInt64: newOp = EOpConvInt64ToUint16; break; + case EbtUint64: newOp = EOpConvUint64ToUint16; break; + case EbtInt16: newOp = EOpConvInt16ToUint16; break; + default: + return nullptr; + } + break; +#endif default: return nullptr; } @@ -1020,6 +1106,10 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat case EbtUint: case EbtInt64: case EbtUint64: +#ifdef AMD_EXTENSIONS + case EbtInt16: + case EbtUint16: +#endif case EbtFloat: case EbtDouble: #ifdef AMD_EXTENSIONS @@ -1033,6 +1123,10 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat switch (from) { case EbtInt: case EbtUint: +#ifdef AMD_EXTENSIONS + case EbtInt16: + case EbtUint16: +#endif case EbtFloat: #ifdef AMD_EXTENSIONS case EbtFloat16: @@ -1048,6 +1142,10 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat case EbtInt: return version >= 400 || (source == EShSourceHlsl); case EbtUint: +#ifdef AMD_EXTENSIONS + case EbtInt16: + case EbtUint16: +#endif return true; case EbtBool: return (source == EShSourceHlsl); @@ -1057,6 +1155,9 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat case EbtInt: switch (from) { case EbtInt: +#ifdef AMD_EXTENSIONS + case EbtInt16: +#endif return true; case EbtBool: return (source == EShSourceHlsl); @@ -1069,6 +1170,10 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat case EbtUint: case EbtInt64: case EbtUint64: +#ifdef AMD_EXTENSIONS + case EbtInt16: + case EbtUint16: +#endif return true; default: return false; @@ -1077,10 +1182,32 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat switch (from) { case EbtInt: case EbtInt64: +#ifdef AMD_EXTENSIONS + case EbtInt16: +#endif return true; default: return false; } +#ifdef AMD_EXTENSIONS + case EbtFloat16: + switch (from) { + case EbtInt16: + case EbtUint16: + case EbtFloat16: + return true; + default: + return false; + } + case EbtUint16: + switch (from) { + case EbtInt16: + case EbtUint16: + return true; + default: + return false; + } +#endif default: return false; } @@ -1313,6 +1440,26 @@ TOperator TIntermediate::mapTypeToConstructorOp(const TType& type) const default: break; // some compilers want this } break; +#ifdef AMD_EXTENSIONS + case EbtInt16: + switch(type.getVectorSize()) { + case 1: op = EOpConstructInt16; break; + case 2: op = EOpConstructI16Vec2; break; + case 3: op = EOpConstructI16Vec3; break; + case 4: op = EOpConstructI16Vec4; break; + default: break; // some compilers want this + } + break; + case EbtUint16: + switch(type.getVectorSize()) { + case 1: op = EOpConstructUint16; break; + case 2: op = EOpConstructU16Vec2; break; + case 3: op = EOpConstructU16Vec3; break; + case 4: op = EOpConstructU16Vec4; break; + default: break; // some compilers want this + } + break; +#endif case EbtBool: if (type.getMatrixCols()) { switch (type.getMatrixCols()) { @@ -1620,6 +1767,24 @@ TIntermConstantUnion* TIntermediate::addConstantUnion(unsigned long long u64, co return addConstantUnion(unionArray, TType(EbtUint64, EvqConst), loc, literal); } +#ifdef AMD_EXTENSIONS +TIntermConstantUnion* TIntermediate::addConstantUnion(short i16, const TSourceLoc& loc, bool literal) const +{ + TConstUnionArray unionArray(1); + unionArray[0].setIConst(i16); + + return addConstantUnion(unionArray, TType(EbtInt16, EvqConst), loc, literal); +} + +TIntermConstantUnion* TIntermediate::addConstantUnion(unsigned short u16, const TSourceLoc& loc, bool literal) const +{ + TConstUnionArray unionArray(1); + unionArray[0].setUConst(u16); + + return addConstantUnion(unionArray, TType(EbtUint16, EvqConst), loc, literal); +} +#endif + TIntermConstantUnion* TIntermediate::addConstantUnion(bool b, const TSourceLoc& loc, bool literal) const { TConstUnionArray unionArray(1); @@ -1979,6 +2144,30 @@ bool TIntermediate::isSpecializationOperation(const TIntermOperator& node) const case EOpConvUintToInt64: case EOpConvUint64ToInt: case EOpConvIntToUint64: +#ifdef AMD_EXTENSIONS + case EOpConvInt16ToBool: + case EOpConvBoolToInt16: + case EOpConvInt16ToInt: + case EOpConvIntToInt16: + case EOpConvInt16ToUint: + case EOpConvUintToInt16: + case EOpConvInt16ToInt64: + case EOpConvInt64ToInt16: + case EOpConvInt16ToUint64: + case EOpConvUint64ToInt16: + case EOpConvUint16ToBool: + case EOpConvBoolToUint16: + case EOpConvUint16ToInt: + case EOpConvIntToUint16: + case EOpConvUint16ToUint: + case EOpConvUintToUint16: + case EOpConvUint16ToInt64: + case EOpConvInt64ToUint16: + case EOpConvUint16ToUint64: + case EOpConvUint64ToUint16: + case EOpConvInt16ToUint16: + case EOpConvUint16ToInt16: +#endif // unary operations case EOpNegative: @@ -2107,6 +2296,10 @@ bool TIntermediate::promoteUnary(TIntermUnary& node) case EOpBitwiseNot: if (operand->getBasicType() != EbtInt && operand->getBasicType() != EbtUint && +#ifdef AMD_EXTENSIONS + operand->getBasicType() != EbtInt16 && + operand->getBasicType() != EbtUint16 && +#endif operand->getBasicType() != EbtInt64 && operand->getBasicType() != EbtUint64) @@ -2121,6 +2314,10 @@ bool TIntermediate::promoteUnary(TIntermUnary& node) operand->getBasicType() != EbtUint && operand->getBasicType() != EbtInt64 && operand->getBasicType() != EbtUint64 && +#ifdef AMD_EXTENSIONS + operand->getBasicType() != EbtInt16 && + operand->getBasicType() != EbtUint16 && +#endif operand->getBasicType() != EbtFloat && #ifdef AMD_EXTENSIONS operand->getBasicType() != EbtFloat16 && @@ -2327,8 +2524,14 @@ bool TIntermediate::promoteBinary(TIntermBinary& node) // Check for integer-only operands. if ((left->getBasicType() != EbtInt && left->getBasicType() != EbtUint && - left->getBasicType() != EbtInt64 && left->getBasicType() != EbtUint64) || +#ifdef AMD_EXTENSIONS + left->getBasicType() != EbtInt16 && left->getBasicType() != EbtUint16 && +#endif + left->getBasicType() != EbtInt64 && left->getBasicType() != EbtUint64) || (right->getBasicType() != EbtInt && right->getBasicType() != EbtUint && +#ifdef AMD_EXTENSIONS + right->getBasicType() != EbtInt16 && right->getBasicType() != EbtUint16 && +#endif right->getBasicType() != EbtInt64 && right->getBasicType() != EbtUint64)) return false; if (left->isMatrix() || right->isMatrix()) diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp index e6d173cc..12dbd164 100644 --- a/glslang/MachineIndependent/ParseHelper.cpp +++ b/glslang/MachineIndependent/ParseHelper.cpp @@ -2220,6 +2220,10 @@ bool TParseContext::constructorError(const TSourceLoc& loc, TIntermNode* node, T case EOpConstructUint: case EOpConstructInt64: case EOpConstructUint64: +#ifdef AMD_EXTENSIONS + case EOpConstructInt16: + case EOpConstructUint16: +#endif case EOpConstructBool: case EOpConstructBVec2: case EOpConstructBVec3: @@ -2236,6 +2240,14 @@ bool TParseContext::constructorError(const TSourceLoc& loc, TIntermNode* node, T case EOpConstructU64Vec2: case EOpConstructU64Vec3: case EOpConstructU64Vec4: +#ifdef AMD_EXTENSIONS + case EOpConstructI16Vec2: + case EOpConstructI16Vec3: + case EOpConstructI16Vec4: + case EOpConstructU16Vec2: + case EOpConstructU16Vec3: + case EOpConstructU16Vec4: +#endif // This was the list of valid ones, if they aren't converting from float // and aren't making an array. makeSpecConst = ! floatArgument && ! type.isArray(); @@ -2528,6 +2540,9 @@ void TParseContext::globalQualifierTypeCheck(const TSourceLoc& loc, const TQuali } if (publicType.basicType == EbtInt || publicType.basicType == EbtUint || +#ifdef AMD_EXTENSIONS + publicType.basicType == EbtInt16 || publicType.basicType == EbtUint16 || +#endif publicType.basicType == EbtInt64 || publicType.basicType == EbtUint64 || publicType.basicType == EbtDouble) profileRequires(loc, EEsProfile, 300, nullptr, "shader input/output"); @@ -2538,6 +2553,9 @@ void TParseContext::globalQualifierTypeCheck(const TSourceLoc& loc, const TQuali if (!qualifier.flat) { #endif if (publicType.basicType == EbtInt || publicType.basicType == EbtUint || +#ifdef AMD_EXTENSIONS + publicType.basicType == EbtInt16 || publicType.basicType == EbtUint16 || +#endif publicType.basicType == EbtInt64 || publicType.basicType == EbtUint64 || publicType.basicType == EbtDouble || (publicType.userDef && (publicType.userDef->containsBasicType(EbtInt) || @@ -4634,6 +4652,10 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type) case EbtUint: case EbtInt64: case EbtUint64: +#ifdef AMD_EXTENSIONS + case EbtInt16: + case EbtUint16: +#endif case EbtBool: case EbtFloat: case EbtDouble: @@ -5580,6 +5602,22 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T basicOp = EOpConstructUint64; break; +#ifdef AMD_EXTENSIONS + case EOpConstructI16Vec2: + case EOpConstructI16Vec3: + case EOpConstructI16Vec4: + case EOpConstructInt16: + basicOp = EOpConstructInt16; + break; + + case EOpConstructU16Vec2: + case EOpConstructU16Vec3: + case EOpConstructU16Vec4: + case EOpConstructUint16: + basicOp = EOpConstructUint16; + break; +#endif + case EOpConstructBVec2: case EOpConstructBVec3: case EOpConstructBVec4: diff --git a/glslang/MachineIndependent/Scan.cpp b/glslang/MachineIndependent/Scan.cpp index f61439f4..3f2f40aa 100644 --- a/glslang/MachineIndependent/Scan.cpp +++ b/glslang/MachineIndependent/Scan.cpp @@ -464,6 +464,15 @@ void TScanContext::fillInKeywordMap() (*KeywordMap)["u64vec4"] = U64VEC4; #ifdef AMD_EXTENSIONS + (*KeywordMap)["int16_t"] = INT16_T; + (*KeywordMap)["uint16_t"] = UINT16_T; + (*KeywordMap)["i16vec2"] = I16VEC2; + (*KeywordMap)["i16vec3"] = I16VEC3; + (*KeywordMap)["i16vec4"] = I16VEC4; + (*KeywordMap)["u16vec2"] = U16VEC2; + (*KeywordMap)["u16vec3"] = U16VEC3; + (*KeywordMap)["u16vec4"] = U16VEC4; + (*KeywordMap)["float16_t"] = FLOAT16_T; (*KeywordMap)["f16vec2"] = F16VEC2; (*KeywordMap)["f16vec3"] = F16VEC3; @@ -709,6 +718,10 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token) case PpAtomConstUint: parserToken->sType.lex.i = ppToken.ival; return UINTCONSTANT; case PpAtomConstInt64: parserToken->sType.lex.i64 = ppToken.i64val; return INT64CONSTANT; case PpAtomConstUint64: parserToken->sType.lex.i64 = ppToken.i64val; return UINT64CONSTANT; +#ifdef AMD_EXTENSIONS + case PpAtomConstInt16: parserToken->sType.lex.i = ppToken.ival; return INT16CONSTANT; + case PpAtomConstUint16: parserToken->sType.lex.i = ppToken.ival; return UINT16CONSTANT; +#endif case PpAtomConstFloat: parserToken->sType.lex.d = ppToken.dval; return FLOATCONSTANT; case PpAtomConstDouble: parserToken->sType.lex.d = ppToken.dval; return DOUBLECONSTANT; #ifdef AMD_EXTENSIONS @@ -973,6 +986,21 @@ int TScanContext::tokenizeIdentifier() return identifierOrType(); #ifdef AMD_EXTENSIONS + case INT16_T: + case UINT16_T: + case I16VEC2: + case I16VEC3: + case I16VEC4: + case U16VEC2: + case U16VEC3: + case U16VEC4: + afterType = true; + if (parseContext.symbolTable.atBuiltInLevel() || + (parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_int16) && + parseContext.profile != EEsProfile && parseContext.version >= 450)) + return keyword; + return identifierOrType(); + case FLOAT16_T: case F16VEC2: case F16VEC3: diff --git a/glslang/MachineIndependent/SymbolTable.cpp b/glslang/MachineIndependent/SymbolTable.cpp index a59ba6b3..d7f9e1d9 100644 --- a/glslang/MachineIndependent/SymbolTable.cpp +++ b/glslang/MachineIndependent/SymbolTable.cpp @@ -67,6 +67,10 @@ void TType::buildMangledName(TString& mangledName) const case EbtUint: mangledName += 'u'; break; case EbtInt64: mangledName += "i64"; break; case EbtUint64: mangledName += "u64"; break; +#ifdef AMD_EXTENSIONS + case EbtInt16: mangledName += "i16"; break; + case EbtUint16: mangledName += "u16"; break; +#endif case EbtBool: mangledName += 'b'; break; case EbtAtomicUint: mangledName += "au"; break; case EbtSampler: diff --git a/glslang/MachineIndependent/Versions.cpp b/glslang/MachineIndependent/Versions.cpp index c85b3e95..800956c9 100644 --- a/glslang/MachineIndependent/Versions.cpp +++ b/glslang/MachineIndependent/Versions.cpp @@ -195,6 +195,7 @@ void TParseVersions::initializeExtensionBehavior() extensionBehavior[E_GL_AMD_gcn_shader] = EBhDisable; extensionBehavior[E_GL_AMD_gpu_shader_half_float] = EBhDisable; extensionBehavior[E_GL_AMD_texture_gather_bias_lod] = EBhDisable; + extensionBehavior[E_GL_AMD_gpu_shader_int16] = EBhDisable; #endif #ifdef NV_EXTENSIONS @@ -318,6 +319,7 @@ void TParseVersions::getPreamble(std::string& preamble) "#define GL_AMD_gcn_shader 1\n" "#define GL_AMD_gpu_shader_half_float 1\n" "#define GL_AMD_texture_gather_bias_lod 1\n" + "#define GL_AMD_gpu_shader_int16 1\n" #endif #ifdef NV_EXTENSIONS @@ -710,10 +712,21 @@ void TParseVersions::doubleCheck(const TSourceLoc& loc, const char* op) } #ifdef AMD_EXTENSIONS -// Call for any operation needing float16 data-type support. +// Call for any operation needing GLSL 16-bit integer data-type support. +void TParseVersions::int16Check(const TSourceLoc& loc, const char* op, bool builtIn) +{ + if (! builtIn) { + requireExtensions(loc, 1, &E_GL_AMD_gpu_shader_int16, "shader int16"); + requireProfile(loc, ECoreProfile | ECompatibilityProfile, op); + profileRequires(loc, ECoreProfile, 450, nullptr, op); + profileRequires(loc, ECompatibilityProfile, 450, nullptr, op); + } +} + +// Call for any operation needing GLSL float16 data-type support. void TParseVersions::float16Check(const TSourceLoc& loc, const char* op, bool builtIn) { - if (!builtIn) { + if (! builtIn) { requireExtensions(loc, 1, &E_GL_AMD_gpu_shader_half_float, "shader half float"); requireProfile(loc, ECoreProfile | ECompatibilityProfile, op); profileRequires(loc, ECoreProfile, 450, nullptr, op); diff --git a/glslang/MachineIndependent/Versions.h b/glslang/MachineIndependent/Versions.h index 483140ca..702a5ae5 100644 --- a/glslang/MachineIndependent/Versions.h +++ b/glslang/MachineIndependent/Versions.h @@ -147,7 +147,9 @@ const char* const E_GL_AMD_shader_explicit_vertex_parameter = "GL_AMD_shader const char* const E_GL_AMD_gcn_shader = "GL_AMD_gcn_shader"; const char* const E_GL_AMD_gpu_shader_half_float = "GL_AMD_gpu_shader_half_float"; const char* const E_GL_AMD_texture_gather_bias_lod = "GL_AMD_texture_gather_bias_lod"; +const char* const E_GL_AMD_gpu_shader_int16 = "GL_AMD_gpu_shader_int16"; #endif + #ifdef NV_EXTENSIONS const char* const E_GL_NV_sample_mask_override_coverage = "GL_NV_sample_mask_override_coverage"; diff --git a/glslang/MachineIndependent/glslang.y b/glslang/MachineIndependent/glslang.y index e609b18e..fd1566fa 100644 --- a/glslang/MachineIndependent/glslang.y +++ b/glslang/MachineIndependent/glslang.y @@ -121,7 +121,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %expect 1 // One shift reduce conflict because of if | else %token ATTRIBUTE VARYING -%token CONST BOOL FLOAT DOUBLE INT UINT INT64_T UINT64_T FLOAT16_T +%token CONST BOOL FLOAT DOUBLE INT UINT INT64_T UINT64_T INT16_T UINT16_T FLOAT16_T %token BREAK CONTINUE DO ELSE FOR IF DISCARD RETURN SWITCH CASE DEFAULT SUBROUTINE %token BVEC2 BVEC3 BVEC4 IVEC2 IVEC3 IVEC4 I64VEC2 I64VEC3 I64VEC4 UVEC2 UVEC3 UVEC4 U64VEC2 U64VEC3 U64VEC4 VEC2 VEC3 VEC4 %token MAT2 MAT3 MAT4 CENTROID IN OUT INOUT @@ -129,6 +129,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %token COHERENT VOLATILE RESTRICT READONLY WRITEONLY %token DVEC2 DVEC3 DVEC4 DMAT2 DMAT3 DMAT4 %token F16VEC2 F16VEC3 F16VEC4 F16MAT2 F16MAT3 F16MAT4 +%token I16VEC2 I16VEC3 I16VEC4 U16VEC2 U16VEC3 U16VEC4 %token NOPERSPECTIVE FLAT SMOOTH LAYOUT __EXPLICITINTERPAMD %token MAT2X2 MAT2X3 MAT2X4 @@ -188,7 +189,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %token STRUCT VOID WHILE %token IDENTIFIER TYPE_NAME -%token FLOATCONSTANT DOUBLECONSTANT INTCONSTANT UINTCONSTANT INT64CONSTANT UINT64CONSTANT BOOLCONSTANT FLOAT16CONSTANT +%token FLOATCONSTANT DOUBLECONSTANT INTCONSTANT UINTCONSTANT INT64CONSTANT UINT64CONSTANT INT16CONSTANT UINT16CONSTANT BOOLCONSTANT FLOAT16CONSTANT %token LEFT_OP RIGHT_OP %token INC_OP DEC_OP LE_OP GE_OP EQ_OP NE_OP %token AND_OP OR_OP XOR_OP MUL_ASSIGN DIV_ASSIGN ADD_ASSIGN @@ -273,6 +274,18 @@ primary_expression parseContext.int64Check($1.loc, "64-bit unsigned integer literal"); $$ = parseContext.intermediate.addConstantUnion($1.u64, $1.loc, true); } + | INT16CONSTANT { +#ifdef AMD_EXTENSIONS + parseContext.int16Check($1.loc, "16-bit integer literal"); + $$ = parseContext.intermediate.addConstantUnion((short)$1.i, $1.loc, true); +#endif + } + | UINT16CONSTANT { +#ifdef AMD_EXTENSIONS + parseContext.int16Check($1.loc, "16-bit unsigned integer literal"); + $$ = parseContext.intermediate.addConstantUnion((unsigned short)$1.u, $1.loc, true); +#endif + } | FLOATCONSTANT { $$ = parseContext.intermediate.addConstantUnion($1.d, EbtFloat, $1.loc, true); } @@ -1363,6 +1376,20 @@ type_specifier_nonarray $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); $$.basicType = EbtUint64; } + | INT16_T { +#ifdef AMD_EXTENSIONS + parseContext.int16Check($1.loc, "16-bit integer", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtInt16; +#endif + } + | UINT16_T { +#ifdef AMD_EXTENSIONS + parseContext.int16Check($1.loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtUint16; +#endif + } | BOOL { $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); $$.basicType = EbtBool; @@ -1472,6 +1499,30 @@ type_specifier_nonarray $$.basicType = EbtInt64; $$.setVector(4); } + | I16VEC2 { +#ifdef AMD_EXTENSIONS + parseContext.int16Check($1.loc, "16-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtInt16; + $$.setVector(2); +#endif + } + | I16VEC3 { +#ifdef AMD_EXTENSIONS + parseContext.int16Check($1.loc, "16-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtInt16; + $$.setVector(3); +#endif + } + | I16VEC4 { +#ifdef AMD_EXTENSIONS + parseContext.int16Check($1.loc, "16-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtInt16; + $$.setVector(4); +#endif + } | UVEC2 { parseContext.fullIntegerCheck($1.loc, "unsigned integer vector"); $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); @@ -1508,6 +1559,30 @@ type_specifier_nonarray $$.basicType = EbtUint64; $$.setVector(4); } + | U16VEC2 { +#ifdef AMD_EXTENSIONS + parseContext.int16Check($1.loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtUint16; + $$.setVector(2); +#endif + } + | U16VEC3 { +#ifdef AMD_EXTENSIONS + parseContext.int16Check($1.loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtUint16; + $$.setVector(3); +#endif + } + | U16VEC4 { +#ifdef AMD_EXTENSIONS + parseContext.int16Check($1.loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtUint16; + $$.setVector(4); +#endif + } | MAT2 { $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); $$.basicType = EbtFloat; diff --git a/glslang/MachineIndependent/glslang_tab.cpp b/glslang/MachineIndependent/glslang_tab.cpp index d27f9910..54a927cc 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp +++ b/glslang/MachineIndependent/glslang_tab.cpp @@ -132,281 +132,291 @@ extern int yydebug; UINT = 265, INT64_T = 266, UINT64_T = 267, - FLOAT16_T = 268, - BREAK = 269, - CONTINUE = 270, - DO = 271, - ELSE = 272, - FOR = 273, - IF = 274, - DISCARD = 275, - RETURN = 276, - SWITCH = 277, - CASE = 278, - DEFAULT = 279, - SUBROUTINE = 280, - BVEC2 = 281, - BVEC3 = 282, - BVEC4 = 283, - IVEC2 = 284, - IVEC3 = 285, - IVEC4 = 286, - I64VEC2 = 287, - I64VEC3 = 288, - I64VEC4 = 289, - UVEC2 = 290, - UVEC3 = 291, - UVEC4 = 292, - U64VEC2 = 293, - U64VEC3 = 294, - U64VEC4 = 295, - VEC2 = 296, - VEC3 = 297, - VEC4 = 298, - MAT2 = 299, - MAT3 = 300, - MAT4 = 301, - CENTROID = 302, - IN = 303, - OUT = 304, - INOUT = 305, - UNIFORM = 306, - PATCH = 307, - SAMPLE = 308, - BUFFER = 309, - SHARED = 310, - COHERENT = 311, - VOLATILE = 312, - RESTRICT = 313, - READONLY = 314, - WRITEONLY = 315, - DVEC2 = 316, - DVEC3 = 317, - DVEC4 = 318, - DMAT2 = 319, - DMAT3 = 320, - DMAT4 = 321, - F16VEC2 = 322, - F16VEC3 = 323, - F16VEC4 = 324, - F16MAT2 = 325, - F16MAT3 = 326, - F16MAT4 = 327, - NOPERSPECTIVE = 328, - FLAT = 329, - SMOOTH = 330, - LAYOUT = 331, - __EXPLICITINTERPAMD = 332, - MAT2X2 = 333, - MAT2X3 = 334, - MAT2X4 = 335, - MAT3X2 = 336, - MAT3X3 = 337, - MAT3X4 = 338, - MAT4X2 = 339, - MAT4X3 = 340, - MAT4X4 = 341, - DMAT2X2 = 342, - DMAT2X3 = 343, - DMAT2X4 = 344, - DMAT3X2 = 345, - DMAT3X3 = 346, - DMAT3X4 = 347, - DMAT4X2 = 348, - DMAT4X3 = 349, - DMAT4X4 = 350, - F16MAT2X2 = 351, - F16MAT2X3 = 352, - F16MAT2X4 = 353, - F16MAT3X2 = 354, - F16MAT3X3 = 355, - F16MAT3X4 = 356, - F16MAT4X2 = 357, - F16MAT4X3 = 358, - F16MAT4X4 = 359, - ATOMIC_UINT = 360, - SAMPLER1D = 361, - SAMPLER2D = 362, - SAMPLER3D = 363, - SAMPLERCUBE = 364, - SAMPLER1DSHADOW = 365, - SAMPLER2DSHADOW = 366, - SAMPLERCUBESHADOW = 367, - SAMPLER1DARRAY = 368, - SAMPLER2DARRAY = 369, - SAMPLER1DARRAYSHADOW = 370, - SAMPLER2DARRAYSHADOW = 371, - ISAMPLER1D = 372, - ISAMPLER2D = 373, - ISAMPLER3D = 374, - ISAMPLERCUBE = 375, - ISAMPLER1DARRAY = 376, - ISAMPLER2DARRAY = 377, - USAMPLER1D = 378, - USAMPLER2D = 379, - USAMPLER3D = 380, - USAMPLERCUBE = 381, - USAMPLER1DARRAY = 382, - USAMPLER2DARRAY = 383, - SAMPLER2DRECT = 384, - SAMPLER2DRECTSHADOW = 385, - ISAMPLER2DRECT = 386, - USAMPLER2DRECT = 387, - SAMPLERBUFFER = 388, - ISAMPLERBUFFER = 389, - USAMPLERBUFFER = 390, - SAMPLERCUBEARRAY = 391, - SAMPLERCUBEARRAYSHADOW = 392, - ISAMPLERCUBEARRAY = 393, - USAMPLERCUBEARRAY = 394, - SAMPLER2DMS = 395, - ISAMPLER2DMS = 396, - USAMPLER2DMS = 397, - SAMPLER2DMSARRAY = 398, - ISAMPLER2DMSARRAY = 399, - USAMPLER2DMSARRAY = 400, - SAMPLEREXTERNALOES = 401, - SAMPLER = 402, - SAMPLERSHADOW = 403, - TEXTURE1D = 404, - TEXTURE2D = 405, - TEXTURE3D = 406, - TEXTURECUBE = 407, - TEXTURE1DARRAY = 408, - TEXTURE2DARRAY = 409, - ITEXTURE1D = 410, - ITEXTURE2D = 411, - ITEXTURE3D = 412, - ITEXTURECUBE = 413, - ITEXTURE1DARRAY = 414, - ITEXTURE2DARRAY = 415, - UTEXTURE1D = 416, - UTEXTURE2D = 417, - UTEXTURE3D = 418, - UTEXTURECUBE = 419, - UTEXTURE1DARRAY = 420, - UTEXTURE2DARRAY = 421, - TEXTURE2DRECT = 422, - ITEXTURE2DRECT = 423, - UTEXTURE2DRECT = 424, - TEXTUREBUFFER = 425, - ITEXTUREBUFFER = 426, - UTEXTUREBUFFER = 427, - TEXTURECUBEARRAY = 428, - ITEXTURECUBEARRAY = 429, - UTEXTURECUBEARRAY = 430, - TEXTURE2DMS = 431, - ITEXTURE2DMS = 432, - UTEXTURE2DMS = 433, - TEXTURE2DMSARRAY = 434, - ITEXTURE2DMSARRAY = 435, - UTEXTURE2DMSARRAY = 436, - SUBPASSINPUT = 437, - SUBPASSINPUTMS = 438, - ISUBPASSINPUT = 439, - ISUBPASSINPUTMS = 440, - USUBPASSINPUT = 441, - USUBPASSINPUTMS = 442, - IMAGE1D = 443, - IIMAGE1D = 444, - UIMAGE1D = 445, - IMAGE2D = 446, - IIMAGE2D = 447, - UIMAGE2D = 448, - IMAGE3D = 449, - IIMAGE3D = 450, - UIMAGE3D = 451, - IMAGE2DRECT = 452, - IIMAGE2DRECT = 453, - UIMAGE2DRECT = 454, - IMAGECUBE = 455, - IIMAGECUBE = 456, - UIMAGECUBE = 457, - IMAGEBUFFER = 458, - IIMAGEBUFFER = 459, - UIMAGEBUFFER = 460, - IMAGE1DARRAY = 461, - IIMAGE1DARRAY = 462, - UIMAGE1DARRAY = 463, - IMAGE2DARRAY = 464, - IIMAGE2DARRAY = 465, - UIMAGE2DARRAY = 466, - IMAGECUBEARRAY = 467, - IIMAGECUBEARRAY = 468, - UIMAGECUBEARRAY = 469, - IMAGE2DMS = 470, - IIMAGE2DMS = 471, - UIMAGE2DMS = 472, - IMAGE2DMSARRAY = 473, - IIMAGE2DMSARRAY = 474, - UIMAGE2DMSARRAY = 475, - STRUCT = 476, - VOID = 477, - WHILE = 478, - IDENTIFIER = 479, - TYPE_NAME = 480, - FLOATCONSTANT = 481, - DOUBLECONSTANT = 482, - INTCONSTANT = 483, - UINTCONSTANT = 484, - INT64CONSTANT = 485, - UINT64CONSTANT = 486, - BOOLCONSTANT = 487, - FLOAT16CONSTANT = 488, - LEFT_OP = 489, - RIGHT_OP = 490, - INC_OP = 491, - DEC_OP = 492, - LE_OP = 493, - GE_OP = 494, - EQ_OP = 495, - NE_OP = 496, - AND_OP = 497, - OR_OP = 498, - XOR_OP = 499, - MUL_ASSIGN = 500, - DIV_ASSIGN = 501, - ADD_ASSIGN = 502, - MOD_ASSIGN = 503, - LEFT_ASSIGN = 504, - RIGHT_ASSIGN = 505, - AND_ASSIGN = 506, - XOR_ASSIGN = 507, - OR_ASSIGN = 508, - SUB_ASSIGN = 509, - LEFT_PAREN = 510, - RIGHT_PAREN = 511, - LEFT_BRACKET = 512, - RIGHT_BRACKET = 513, - LEFT_BRACE = 514, - RIGHT_BRACE = 515, - DOT = 516, - COMMA = 517, - COLON = 518, - EQUAL = 519, - SEMICOLON = 520, - BANG = 521, - DASH = 522, - TILDE = 523, - PLUS = 524, - STAR = 525, - SLASH = 526, - PERCENT = 527, - LEFT_ANGLE = 528, - RIGHT_ANGLE = 529, - VERTICAL_BAR = 530, - CARET = 531, - AMPERSAND = 532, - QUESTION = 533, - INVARIANT = 534, - PRECISE = 535, - HIGH_PRECISION = 536, - MEDIUM_PRECISION = 537, - LOW_PRECISION = 538, - PRECISION = 539, - PACKED = 540, - RESOURCE = 541, - SUPERP = 542 + INT16_T = 268, + UINT16_T = 269, + FLOAT16_T = 270, + BREAK = 271, + CONTINUE = 272, + DO = 273, + ELSE = 274, + FOR = 275, + IF = 276, + DISCARD = 277, + RETURN = 278, + SWITCH = 279, + CASE = 280, + DEFAULT = 281, + SUBROUTINE = 282, + BVEC2 = 283, + BVEC3 = 284, + BVEC4 = 285, + IVEC2 = 286, + IVEC3 = 287, + IVEC4 = 288, + I64VEC2 = 289, + I64VEC3 = 290, + I64VEC4 = 291, + UVEC2 = 292, + UVEC3 = 293, + UVEC4 = 294, + U64VEC2 = 295, + U64VEC3 = 296, + U64VEC4 = 297, + VEC2 = 298, + VEC3 = 299, + VEC4 = 300, + MAT2 = 301, + MAT3 = 302, + MAT4 = 303, + CENTROID = 304, + IN = 305, + OUT = 306, + INOUT = 307, + UNIFORM = 308, + PATCH = 309, + SAMPLE = 310, + BUFFER = 311, + SHARED = 312, + COHERENT = 313, + VOLATILE = 314, + RESTRICT = 315, + READONLY = 316, + WRITEONLY = 317, + DVEC2 = 318, + DVEC3 = 319, + DVEC4 = 320, + DMAT2 = 321, + DMAT3 = 322, + DMAT4 = 323, + F16VEC2 = 324, + F16VEC3 = 325, + F16VEC4 = 326, + F16MAT2 = 327, + F16MAT3 = 328, + F16MAT4 = 329, + I16VEC2 = 330, + I16VEC3 = 331, + I16VEC4 = 332, + U16VEC2 = 333, + U16VEC3 = 334, + U16VEC4 = 335, + NOPERSPECTIVE = 336, + FLAT = 337, + SMOOTH = 338, + LAYOUT = 339, + __EXPLICITINTERPAMD = 340, + MAT2X2 = 341, + MAT2X3 = 342, + MAT2X4 = 343, + MAT3X2 = 344, + MAT3X3 = 345, + MAT3X4 = 346, + MAT4X2 = 347, + MAT4X3 = 348, + MAT4X4 = 349, + DMAT2X2 = 350, + DMAT2X3 = 351, + DMAT2X4 = 352, + DMAT3X2 = 353, + DMAT3X3 = 354, + DMAT3X4 = 355, + DMAT4X2 = 356, + DMAT4X3 = 357, + DMAT4X4 = 358, + F16MAT2X2 = 359, + F16MAT2X3 = 360, + F16MAT2X4 = 361, + F16MAT3X2 = 362, + F16MAT3X3 = 363, + F16MAT3X4 = 364, + F16MAT4X2 = 365, + F16MAT4X3 = 366, + F16MAT4X4 = 367, + ATOMIC_UINT = 368, + SAMPLER1D = 369, + SAMPLER2D = 370, + SAMPLER3D = 371, + SAMPLERCUBE = 372, + SAMPLER1DSHADOW = 373, + SAMPLER2DSHADOW = 374, + SAMPLERCUBESHADOW = 375, + SAMPLER1DARRAY = 376, + SAMPLER2DARRAY = 377, + SAMPLER1DARRAYSHADOW = 378, + SAMPLER2DARRAYSHADOW = 379, + ISAMPLER1D = 380, + ISAMPLER2D = 381, + ISAMPLER3D = 382, + ISAMPLERCUBE = 383, + ISAMPLER1DARRAY = 384, + ISAMPLER2DARRAY = 385, + USAMPLER1D = 386, + USAMPLER2D = 387, + USAMPLER3D = 388, + USAMPLERCUBE = 389, + USAMPLER1DARRAY = 390, + USAMPLER2DARRAY = 391, + SAMPLER2DRECT = 392, + SAMPLER2DRECTSHADOW = 393, + ISAMPLER2DRECT = 394, + USAMPLER2DRECT = 395, + SAMPLERBUFFER = 396, + ISAMPLERBUFFER = 397, + USAMPLERBUFFER = 398, + SAMPLERCUBEARRAY = 399, + SAMPLERCUBEARRAYSHADOW = 400, + ISAMPLERCUBEARRAY = 401, + USAMPLERCUBEARRAY = 402, + SAMPLER2DMS = 403, + ISAMPLER2DMS = 404, + USAMPLER2DMS = 405, + SAMPLER2DMSARRAY = 406, + ISAMPLER2DMSARRAY = 407, + USAMPLER2DMSARRAY = 408, + SAMPLEREXTERNALOES = 409, + SAMPLER = 410, + SAMPLERSHADOW = 411, + TEXTURE1D = 412, + TEXTURE2D = 413, + TEXTURE3D = 414, + TEXTURECUBE = 415, + TEXTURE1DARRAY = 416, + TEXTURE2DARRAY = 417, + ITEXTURE1D = 418, + ITEXTURE2D = 419, + ITEXTURE3D = 420, + ITEXTURECUBE = 421, + ITEXTURE1DARRAY = 422, + ITEXTURE2DARRAY = 423, + UTEXTURE1D = 424, + UTEXTURE2D = 425, + UTEXTURE3D = 426, + UTEXTURECUBE = 427, + UTEXTURE1DARRAY = 428, + UTEXTURE2DARRAY = 429, + TEXTURE2DRECT = 430, + ITEXTURE2DRECT = 431, + UTEXTURE2DRECT = 432, + TEXTUREBUFFER = 433, + ITEXTUREBUFFER = 434, + UTEXTUREBUFFER = 435, + TEXTURECUBEARRAY = 436, + ITEXTURECUBEARRAY = 437, + UTEXTURECUBEARRAY = 438, + TEXTURE2DMS = 439, + ITEXTURE2DMS = 440, + UTEXTURE2DMS = 441, + TEXTURE2DMSARRAY = 442, + ITEXTURE2DMSARRAY = 443, + UTEXTURE2DMSARRAY = 444, + SUBPASSINPUT = 445, + SUBPASSINPUTMS = 446, + ISUBPASSINPUT = 447, + ISUBPASSINPUTMS = 448, + USUBPASSINPUT = 449, + USUBPASSINPUTMS = 450, + IMAGE1D = 451, + IIMAGE1D = 452, + UIMAGE1D = 453, + IMAGE2D = 454, + IIMAGE2D = 455, + UIMAGE2D = 456, + IMAGE3D = 457, + IIMAGE3D = 458, + UIMAGE3D = 459, + IMAGE2DRECT = 460, + IIMAGE2DRECT = 461, + UIMAGE2DRECT = 462, + IMAGECUBE = 463, + IIMAGECUBE = 464, + UIMAGECUBE = 465, + IMAGEBUFFER = 466, + IIMAGEBUFFER = 467, + UIMAGEBUFFER = 468, + IMAGE1DARRAY = 469, + IIMAGE1DARRAY = 470, + UIMAGE1DARRAY = 471, + IMAGE2DARRAY = 472, + IIMAGE2DARRAY = 473, + UIMAGE2DARRAY = 474, + IMAGECUBEARRAY = 475, + IIMAGECUBEARRAY = 476, + UIMAGECUBEARRAY = 477, + IMAGE2DMS = 478, + IIMAGE2DMS = 479, + UIMAGE2DMS = 480, + IMAGE2DMSARRAY = 481, + IIMAGE2DMSARRAY = 482, + UIMAGE2DMSARRAY = 483, + STRUCT = 484, + VOID = 485, + WHILE = 486, + IDENTIFIER = 487, + TYPE_NAME = 488, + FLOATCONSTANT = 489, + DOUBLECONSTANT = 490, + INTCONSTANT = 491, + UINTCONSTANT = 492, + INT64CONSTANT = 493, + UINT64CONSTANT = 494, + INT16CONSTANT = 495, + UINT16CONSTANT = 496, + BOOLCONSTANT = 497, + FLOAT16CONSTANT = 498, + LEFT_OP = 499, + RIGHT_OP = 500, + INC_OP = 501, + DEC_OP = 502, + LE_OP = 503, + GE_OP = 504, + EQ_OP = 505, + NE_OP = 506, + AND_OP = 507, + OR_OP = 508, + XOR_OP = 509, + MUL_ASSIGN = 510, + DIV_ASSIGN = 511, + ADD_ASSIGN = 512, + MOD_ASSIGN = 513, + LEFT_ASSIGN = 514, + RIGHT_ASSIGN = 515, + AND_ASSIGN = 516, + XOR_ASSIGN = 517, + OR_ASSIGN = 518, + SUB_ASSIGN = 519, + LEFT_PAREN = 520, + RIGHT_PAREN = 521, + LEFT_BRACKET = 522, + RIGHT_BRACKET = 523, + LEFT_BRACE = 524, + RIGHT_BRACE = 525, + DOT = 526, + COMMA = 527, + COLON = 528, + EQUAL = 529, + SEMICOLON = 530, + BANG = 531, + DASH = 532, + TILDE = 533, + PLUS = 534, + STAR = 535, + SLASH = 536, + PERCENT = 537, + LEFT_ANGLE = 538, + RIGHT_ANGLE = 539, + VERTICAL_BAR = 540, + CARET = 541, + AMPERSAND = 542, + QUESTION = 543, + INVARIANT = 544, + PRECISE = 545, + HIGH_PRECISION = 546, + MEDIUM_PRECISION = 547, + LOW_PRECISION = 548, + PRECISION = 549, + PACKED = 550, + RESOURCE = 551, + SUPERP = 552 }; #endif @@ -449,7 +459,7 @@ union YYSTYPE }; } interm; -#line 453 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355 */ +#line 463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355 */ }; typedef union YYSTYPE YYSTYPE; @@ -480,7 +490,7 @@ int yyparse (glslang::TParseContext* pParseContext); extern int yylex(YYSTYPE*, TParseContext&); -#line 484 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358 */ +#line 494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358 */ #ifdef short # undef short @@ -720,23 +730,23 @@ union yyalloc #endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ -#define YYFINAL 265 +#define YYFINAL 273 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 6373 +#define YYLAST 6608 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 288 +#define YYNTOKENS 298 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 100 /* YYNRULES -- Number of rules. */ -#define YYNRULES 439 +#define YYNRULES 449 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 571 +#define YYNSTATES 581 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 542 +#define YYMAXUTOK 552 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) @@ -799,57 +809,59 @@ static const yytype_uint16 yytranslate[] = 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 + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297 }; #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { - 0, 252, 252, 258, 261, 264, 268, 272, 276, 279, - 283, 289, 292, 300, 303, 306, 309, 312, 317, 325, - 332, 339, 345, 349, 356, 359, 365, 372, 382, 390, - 395, 425, 431, 435, 439, 459, 460, 461, 462, 468, - 469, 474, 479, 488, 489, 494, 502, 503, 509, 518, - 519, 524, 529, 534, 542, 543, 551, 562, 563, 572, - 573, 582, 583, 592, 593, 601, 602, 610, 611, 619, - 620, 620, 638, 639, 654, 658, 662, 666, 671, 675, - 679, 683, 687, 691, 695, 702, 705, 716, 723, 728, - 733, 741, 745, 749, 753, 758, 763, 772, 772, 783, - 787, 794, 801, 804, 811, 819, 839, 857, 872, 895, - 906, 916, 926, 936, 945, 948, 952, 956, 961, 969, - 974, 979, 984, 989, 998, 1009, 1036, 1045, 1052, 1059, - 1066, 1078, 1084, 1087, 1094, 1098, 1102, 1110, 1119, 1122, - 1133, 1136, 1139, 1143, 1147, 1151, 1158, 1162, 1174, 1188, - 1193, 1199, 1205, 1212, 1218, 1223, 1228, 1233, 1241, 1245, - 1249, 1253, 1257, 1261, 1267, 1276, 1279, 1287, 1291, 1300, - 1305, 1313, 1317, 1327, 1331, 1335, 1340, 1347, 1351, 1356, - 1361, 1366, 1370, 1375, 1380, 1385, 1391, 1397, 1403, 1411, - 1419, 1427, 1432, 1437, 1442, 1447, 1452, 1457, 1463, 1469, - 1475, 1481, 1487, 1493, 1499, 1505, 1511, 1516, 1521, 1526, - 1531, 1536, 1541, 1546, 1551, 1556, 1561, 1566, 1571, 1577, - 1583, 1589, 1595, 1601, 1607, 1613, 1619, 1625, 1631, 1637, - 1643, 1651, 1659, 1667, 1675, 1683, 1691, 1699, 1707, 1715, - 1723, 1731, 1739, 1744, 1749, 1754, 1759, 1764, 1769, 1774, - 1779, 1784, 1789, 1794, 1799, 1804, 1809, 1814, 1819, 1824, - 1829, 1834, 1839, 1844, 1849, 1854, 1859, 1864, 1869, 1874, - 1879, 1884, 1889, 1894, 1899, 1904, 1909, 1914, 1919, 1924, - 1929, 1934, 1939, 1944, 1949, 1954, 1959, 1964, 1969, 1974, - 1979, 1984, 1989, 1994, 1999, 2004, 2009, 2014, 2019, 2024, - 2029, 2034, 2039, 2044, 2049, 2054, 2059, 2064, 2069, 2074, - 2079, 2084, 2089, 2094, 2099, 2104, 2109, 2114, 2119, 2124, - 2129, 2134, 2139, 2144, 2149, 2154, 2159, 2164, 2169, 2174, - 2179, 2184, 2189, 2194, 2199, 2204, 2209, 2214, 2219, 2224, - 2229, 2234, 2239, 2244, 2249, 2254, 2259, 2264, 2269, 2274, - 2279, 2284, 2290, 2296, 2302, 2308, 2314, 2320, 2326, 2331, - 2347, 2352, 2357, 2365, 2365, 2376, 2376, 2386, 2389, 2402, - 2420, 2444, 2448, 2454, 2459, 2470, 2473, 2479, 2488, 2491, - 2497, 2501, 2502, 2508, 2509, 2510, 2511, 2512, 2513, 2514, - 2518, 2519, 2523, 2519, 2535, 2536, 2540, 2540, 2547, 2547, - 2561, 2564, 2572, 2580, 2591, 2592, 2596, 2603, 2607, 2615, - 2619, 2632, 2632, 2652, 2655, 2661, 2673, 2685, 2685, 2700, - 2700, 2716, 2716, 2737, 2740, 2746, 2749, 2755, 2759, 2766, - 2771, 2776, 2783, 2786, 2795, 2799, 2806, 2809, 2815, 2815 + 0, 253, 253, 259, 262, 265, 269, 273, 277, 283, + 289, 292, 296, 302, 305, 313, 316, 319, 322, 325, + 330, 338, 345, 352, 358, 362, 369, 372, 378, 385, + 395, 403, 408, 438, 444, 448, 452, 472, 473, 474, + 475, 481, 482, 487, 492, 501, 502, 507, 515, 516, + 522, 531, 532, 537, 542, 547, 555, 556, 564, 575, + 576, 585, 586, 595, 596, 605, 606, 614, 615, 623, + 624, 632, 633, 633, 651, 652, 667, 671, 675, 679, + 684, 688, 692, 696, 700, 704, 708, 715, 718, 729, + 736, 741, 746, 754, 758, 762, 766, 771, 776, 785, + 785, 796, 800, 807, 814, 817, 824, 832, 852, 870, + 885, 908, 919, 929, 939, 949, 958, 961, 965, 969, + 974, 982, 987, 992, 997, 1002, 1011, 1022, 1049, 1058, + 1065, 1072, 1079, 1091, 1097, 1100, 1107, 1111, 1115, 1123, + 1132, 1135, 1146, 1149, 1152, 1156, 1160, 1164, 1171, 1175, + 1187, 1201, 1206, 1212, 1218, 1225, 1231, 1236, 1241, 1246, + 1254, 1258, 1262, 1266, 1270, 1274, 1280, 1289, 1292, 1300, + 1304, 1313, 1318, 1326, 1330, 1340, 1344, 1348, 1353, 1360, + 1364, 1369, 1374, 1379, 1386, 1393, 1397, 1402, 1407, 1412, + 1418, 1424, 1430, 1438, 1446, 1454, 1459, 1464, 1469, 1474, + 1479, 1484, 1490, 1496, 1502, 1510, 1518, 1526, 1532, 1538, + 1544, 1550, 1556, 1562, 1570, 1578, 1586, 1591, 1596, 1601, + 1606, 1611, 1616, 1621, 1626, 1631, 1636, 1641, 1646, 1652, + 1658, 1664, 1670, 1676, 1682, 1688, 1694, 1700, 1706, 1712, + 1718, 1726, 1734, 1742, 1750, 1758, 1766, 1774, 1782, 1790, + 1798, 1806, 1814, 1819, 1824, 1829, 1834, 1839, 1844, 1849, + 1854, 1859, 1864, 1869, 1874, 1879, 1884, 1889, 1894, 1899, + 1904, 1909, 1914, 1919, 1924, 1929, 1934, 1939, 1944, 1949, + 1954, 1959, 1964, 1969, 1974, 1979, 1984, 1989, 1994, 1999, + 2004, 2009, 2014, 2019, 2024, 2029, 2034, 2039, 2044, 2049, + 2054, 2059, 2064, 2069, 2074, 2079, 2084, 2089, 2094, 2099, + 2104, 2109, 2114, 2119, 2124, 2129, 2134, 2139, 2144, 2149, + 2154, 2159, 2164, 2169, 2174, 2179, 2184, 2189, 2194, 2199, + 2204, 2209, 2214, 2219, 2224, 2229, 2234, 2239, 2244, 2249, + 2254, 2259, 2264, 2269, 2274, 2279, 2284, 2289, 2294, 2299, + 2304, 2309, 2314, 2319, 2324, 2329, 2334, 2339, 2344, 2349, + 2354, 2359, 2365, 2371, 2377, 2383, 2389, 2395, 2401, 2406, + 2422, 2427, 2432, 2440, 2440, 2451, 2451, 2461, 2464, 2477, + 2495, 2519, 2523, 2529, 2534, 2545, 2548, 2554, 2563, 2566, + 2572, 2576, 2577, 2583, 2584, 2585, 2586, 2587, 2588, 2589, + 2593, 2594, 2598, 2594, 2610, 2611, 2615, 2615, 2622, 2622, + 2636, 2639, 2647, 2655, 2666, 2667, 2671, 2678, 2682, 2690, + 2694, 2707, 2707, 2727, 2730, 2736, 2748, 2760, 2760, 2775, + 2775, 2791, 2791, 2812, 2815, 2821, 2824, 2830, 2834, 2841, + 2846, 2851, 2858, 2861, 2870, 2874, 2881, 2884, 2890, 2890 }; #endif @@ -859,34 +871,35 @@ static const yytype_uint16 yyrline[] = static const char *const yytname[] = { "$end", "error", "$undefined", "ATTRIBUTE", "VARYING", "CONST", "BOOL", - "FLOAT", "DOUBLE", "INT", "UINT", "INT64_T", "UINT64_T", "FLOAT16_T", - "BREAK", "CONTINUE", "DO", "ELSE", "FOR", "IF", "DISCARD", "RETURN", - "SWITCH", "CASE", "DEFAULT", "SUBROUTINE", "BVEC2", "BVEC3", "BVEC4", - "IVEC2", "IVEC3", "IVEC4", "I64VEC2", "I64VEC3", "I64VEC4", "UVEC2", - "UVEC3", "UVEC4", "U64VEC2", "U64VEC3", "U64VEC4", "VEC2", "VEC3", - "VEC4", "MAT2", "MAT3", "MAT4", "CENTROID", "IN", "OUT", "INOUT", - "UNIFORM", "PATCH", "SAMPLE", "BUFFER", "SHARED", "COHERENT", "VOLATILE", - "RESTRICT", "READONLY", "WRITEONLY", "DVEC2", "DVEC3", "DVEC4", "DMAT2", - "DMAT3", "DMAT4", "F16VEC2", "F16VEC3", "F16VEC4", "F16MAT2", "F16MAT3", - "F16MAT4", "NOPERSPECTIVE", "FLAT", "SMOOTH", "LAYOUT", - "__EXPLICITINTERPAMD", "MAT2X2", "MAT2X3", "MAT2X4", "MAT3X2", "MAT3X3", - "MAT3X4", "MAT4X2", "MAT4X3", "MAT4X4", "DMAT2X2", "DMAT2X3", "DMAT2X4", - "DMAT3X2", "DMAT3X3", "DMAT3X4", "DMAT4X2", "DMAT4X3", "DMAT4X4", - "F16MAT2X2", "F16MAT2X3", "F16MAT2X4", "F16MAT3X2", "F16MAT3X3", - "F16MAT3X4", "F16MAT4X2", "F16MAT4X3", "F16MAT4X4", "ATOMIC_UINT", - "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", "SAMPLER", "SAMPLERSHADOW", "TEXTURE1D", - "TEXTURE2D", "TEXTURE3D", "TEXTURECUBE", "TEXTURE1DARRAY", + "FLOAT", "DOUBLE", "INT", "UINT", "INT64_T", "UINT64_T", "INT16_T", + "UINT16_T", "FLOAT16_T", "BREAK", "CONTINUE", "DO", "ELSE", "FOR", "IF", + "DISCARD", "RETURN", "SWITCH", "CASE", "DEFAULT", "SUBROUTINE", "BVEC2", + "BVEC3", "BVEC4", "IVEC2", "IVEC3", "IVEC4", "I64VEC2", "I64VEC3", + "I64VEC4", "UVEC2", "UVEC3", "UVEC4", "U64VEC2", "U64VEC3", "U64VEC4", + "VEC2", "VEC3", "VEC4", "MAT2", "MAT3", "MAT4", "CENTROID", "IN", "OUT", + "INOUT", "UNIFORM", "PATCH", "SAMPLE", "BUFFER", "SHARED", "COHERENT", + "VOLATILE", "RESTRICT", "READONLY", "WRITEONLY", "DVEC2", "DVEC3", + "DVEC4", "DMAT2", "DMAT3", "DMAT4", "F16VEC2", "F16VEC3", "F16VEC4", + "F16MAT2", "F16MAT3", "F16MAT4", "I16VEC2", "I16VEC3", "I16VEC4", + "U16VEC2", "U16VEC3", "U16VEC4", "NOPERSPECTIVE", "FLAT", "SMOOTH", + "LAYOUT", "__EXPLICITINTERPAMD", "MAT2X2", "MAT2X3", "MAT2X4", "MAT3X2", + "MAT3X3", "MAT3X4", "MAT4X2", "MAT4X3", "MAT4X4", "DMAT2X2", "DMAT2X3", + "DMAT2X4", "DMAT3X2", "DMAT3X3", "DMAT3X4", "DMAT4X2", "DMAT4X3", + "DMAT4X4", "F16MAT2X2", "F16MAT2X3", "F16MAT2X4", "F16MAT3X2", + "F16MAT3X3", "F16MAT3X4", "F16MAT4X2", "F16MAT4X3", "F16MAT4X4", + "ATOMIC_UINT", "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", "SAMPLER", "SAMPLERSHADOW", + "TEXTURE1D", "TEXTURE2D", "TEXTURE3D", "TEXTURECUBE", "TEXTURE1DARRAY", "TEXTURE2DARRAY", "ITEXTURE1D", "ITEXTURE2D", "ITEXTURE3D", "ITEXTURECUBE", "ITEXTURE1DARRAY", "ITEXTURE2DARRAY", "UTEXTURE1D", "UTEXTURE2D", "UTEXTURE3D", "UTEXTURECUBE", "UTEXTURE1DARRAY", @@ -905,20 +918,20 @@ static const char *const yytname[] = "UIMAGE2DMS", "IMAGE2DMSARRAY", "IIMAGE2DMSARRAY", "UIMAGE2DMSARRAY", "STRUCT", "VOID", "WHILE", "IDENTIFIER", "TYPE_NAME", "FLOATCONSTANT", "DOUBLECONSTANT", "INTCONSTANT", "UINTCONSTANT", "INT64CONSTANT", - "UINT64CONSTANT", "BOOLCONSTANT", "FLOAT16CONSTANT", "LEFT_OP", - "RIGHT_OP", "INC_OP", "DEC_OP", "LE_OP", "GE_OP", "EQ_OP", "NE_OP", - "AND_OP", "OR_OP", "XOR_OP", "MUL_ASSIGN", "DIV_ASSIGN", "ADD_ASSIGN", - "MOD_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", - "OR_ASSIGN", "SUB_ASSIGN", "LEFT_PAREN", "RIGHT_PAREN", "LEFT_BRACKET", - "RIGHT_BRACKET", "LEFT_BRACE", "RIGHT_BRACE", "DOT", "COMMA", "COLON", - "EQUAL", "SEMICOLON", "BANG", "DASH", "TILDE", "PLUS", "STAR", "SLASH", - "PERCENT", "LEFT_ANGLE", "RIGHT_ANGLE", "VERTICAL_BAR", "CARET", - "AMPERSAND", "QUESTION", "INVARIANT", "PRECISE", "HIGH_PRECISION", - "MEDIUM_PRECISION", "LOW_PRECISION", "PRECISION", "PACKED", "RESOURCE", - "SUPERP", "$accept", "variable_identifier", "primary_expression", - "postfix_expression", "integer_expression", "function_call", - "function_call_or_method", "function_call_generic", - "function_call_header_no_parameters", + "UINT64CONSTANT", "INT16CONSTANT", "UINT16CONSTANT", "BOOLCONSTANT", + "FLOAT16CONSTANT", "LEFT_OP", "RIGHT_OP", "INC_OP", "DEC_OP", "LE_OP", + "GE_OP", "EQ_OP", "NE_OP", "AND_OP", "OR_OP", "XOR_OP", "MUL_ASSIGN", + "DIV_ASSIGN", "ADD_ASSIGN", "MOD_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN", + "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "SUB_ASSIGN", "LEFT_PAREN", + "RIGHT_PAREN", "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_BRACE", + "RIGHT_BRACE", "DOT", "COMMA", "COLON", "EQUAL", "SEMICOLON", "BANG", + "DASH", "TILDE", "PLUS", "STAR", "SLASH", "PERCENT", "LEFT_ANGLE", + "RIGHT_ANGLE", "VERTICAL_BAR", "CARET", "AMPERSAND", "QUESTION", + "INVARIANT", "PRECISE", "HIGH_PRECISION", "MEDIUM_PRECISION", + "LOW_PRECISION", "PRECISION", "PACKED", "RESOURCE", "SUPERP", "$accept", + "variable_identifier", "primary_expression", "postfix_expression", + "integer_expression", "function_call", "function_call_or_method", + "function_call_generic", "function_call_header_no_parameters", "function_call_header_with_parameters", "function_call_header", "function_identifier", "unary_expression", "unary_operator", "multiplicative_expression", "additive_expression", "shift_expression", @@ -985,16 +998,17 @@ static const yytype_uint16 yytoknum[] = 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, - 535, 536, 537, 538, 539, 540, 541, 542 + 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, + 545, 546, 547, 548, 549, 550, 551, 552 }; # endif -#define YYPACT_NINF -512 +#define YYPACT_NINF -522 #define yypact_value_is_default(Yystate) \ - (!!((Yystate) == (-512))) + (!!((Yystate) == (-522))) -#define YYTABLE_NINF -397 +#define YYTABLE_NINF -407 #define yytable_value_is_error(Yytable_value) \ 0 @@ -1003,64 +1017,65 @@ static const yytype_uint16 yytoknum[] = STATE-NUM. */ static const yytype_int16 yypact[] = { - 2538, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -235, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -201, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, -512, -203, -512, - -512, -512, -512, -512, -512, -512, -153, -512, -210, -220, - -152, -189, 4119, -160, -512, -128, -512, -512, -512, -512, - 3079, -512, -512, -512, -122, -512, -512, 564, -512, -512, - -71, -46, -105, -512, 6148, -216, -512, -512, -102, -512, - 4119, -512, -512, -512, 4119, -68, -66, -512, -225, -187, - -512, -512, -512, 4606, -98, -512, -512, -512, -179, -512, - -104, -172, -512, -512, 4119, -101, -512, -186, 846, -512, - -512, -512, -512, -122, -233, -512, 4870, -217, -512, -63, - -512, -151, -512, -512, -512, -512, -512, -512, -512, -512, - -512, 5648, 5648, 5648, -512, -512, -512, -512, -512, -512, - -512, -209, -512, -512, -512, -94, -170, 5898, -92, -512, - 5648, -139, -133, -109, -223, -103, -111, -108, -106, -72, - -73, -218, -86, -512, 5134, -512, -51, 5648, -512, -46, - 4119, 4119, -50, 3342, -512, -512, -512, -90, -89, -512, - -78, -76, -85, 5398, -70, 5648, -80, -69, -64, -512, - -512, -184, -512, -512, -150, -512, -220, -67, -512, -512, - -512, -512, 1128, -512, -512, -512, -512, -512, -512, -98, - 4870, -183, 4870, -512, -512, 4870, 4119, -512, -40, -512, - -512, -512, -169, -512, -512, 5648, -35, -512, -512, 5648, - -65, -512, -512, -512, 5648, 5648, 5648, 5648, 5648, 5648, - 5648, 5648, 5648, 5648, 5648, 5648, 5648, 5648, 5648, 5648, - 5648, 5648, 5648, -512, -512, -512, -61, -512, -512, -512, - -512, 3601, -50, -122, -144, -512, -512, -512, -512, -512, - 1410, -512, 5648, -512, -512, -142, 5648, -123, -512, -512, - -512, 1410, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -512, 5648, 5648, -512, -512, -512, -512, 4870, - -512, -226, -512, 3860, -512, -512, -60, -62, -512, -512, - -512, -512, -512, -139, -139, -133, -133, -109, -109, -109, - -109, -223, -223, -103, -111, -108, -106, -72, -73, 5648, - -512, -512, -138, -98, -50, -512, -33, 2256, -168, -512, - -167, -512, 2798, 1410, -512, -512, -512, -512, 4342, -512, - -512, -121, -512, -512, -56, -512, -512, 2798, -58, -512, - -62, -32, 4119, -52, -53, -512, -512, 5648, 5648, -512, - -57, -47, 177, -48, 1974, -512, -45, -49, 1692, -512, - -512, -165, 5648, 1692, -58, -512, -512, 1410, 4870, -512, - -512, -512, -44, -62, -512, -512, 1410, -43, -512, -512, - -512 + 2618, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -224, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -217, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -214, -522, -522, -522, + -522, -522, -522, -522, -261, -522, -215, -213, -184, -182, + 4254, -196, -522, -122, -522, -522, -522, -522, 3177, -522, + -522, -522, -129, -522, -522, 574, -522, -522, -90, -48, + -125, -522, 6375, -232, -522, -522, -117, -522, 4254, -522, + -522, -522, 4254, -75, -74, -522, -240, -183, -522, -522, + -522, 4759, -108, -522, -522, -522, -179, -522, -114, -175, + -522, -522, 4254, -113, -522, -216, 866, -522, -522, -522, + -522, -129, -222, -522, 5033, -193, -522, -71, -522, -158, + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, 5855, 5855, 5855, -522, -522, -522, -522, -522, -522, + -522, -227, -522, -522, -522, -102, -164, 6115, -100, -522, + 5855, -145, -199, -195, -226, -128, -124, -120, -116, -82, + -83, -225, -96, -522, 5307, -522, -59, 5855, -522, -48, + 4254, 4254, -58, 3450, -522, -522, -522, -99, -98, -522, + -87, -86, -95, 5581, -84, 5855, -88, -79, -80, -522, + -522, -191, -522, -522, -156, -522, -213, -78, -522, -522, + -522, -522, 1158, -522, -522, -522, -522, -522, -522, -108, + 5033, -190, 5033, -522, -522, 5033, 4254, -522, -57, -522, + -522, -522, -163, -522, -522, 5855, -41, -522, -522, 5855, + -73, -522, -522, -522, 5855, 5855, 5855, 5855, 5855, 5855, + 5855, 5855, 5855, 5855, 5855, 5855, 5855, 5855, 5855, 5855, + 5855, 5855, 5855, -522, -522, -522, -76, -522, -522, -522, + -522, 3718, -58, -129, -143, -522, -522, -522, -522, -522, + 1450, -522, 5855, -522, -522, -142, 5855, -178, -522, -522, + -522, 1450, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -522, 5855, 5855, -522, -522, -522, -522, 5033, + -522, -131, -522, 3986, -522, -522, -72, -77, -522, -522, + -522, -522, -522, -145, -145, -199, -199, -195, -195, -195, + -195, -226, -226, -128, -124, -120, -116, -82, -83, 5855, + -522, -522, -141, -108, -58, -522, -37, 2326, -161, -522, + -160, -522, 2886, 1450, -522, -522, -522, -522, 4485, -522, + -522, -127, -522, -522, -68, -522, -522, 2886, -70, -522, + -77, -30, 4254, -63, -66, -522, -522, 5855, 5855, -522, + -69, -61, 188, -55, 2034, -522, -54, -64, 1742, -522, + -522, -159, 5855, 1742, -70, -522, -522, 1450, 5033, -522, + -522, -522, -56, -77, -522, -522, 1450, -53, -522, -522, + -522 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -1068,94 +1083,95 @@ static const yytype_int16 yypact[] = means the default is an error. */ static const yytype_uint16 yydefact[] = { - 0, 147, 148, 146, 181, 174, 175, 177, 178, 179, - 180, 176, 163, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 182, 183, - 184, 206, 207, 208, 152, 150, 151, 149, 155, 153, - 154, 156, 157, 158, 159, 160, 161, 162, 185, 186, - 187, 218, 219, 220, 188, 189, 190, 230, 231, 232, - 129, 128, 127, 0, 130, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 256, 257, 258, 259, 260, 261, - 263, 264, 265, 266, 267, 268, 270, 271, 272, 273, - 274, 275, 276, 254, 255, 262, 269, 277, 278, 279, - 280, 281, 282, 351, 283, 284, 285, 286, 287, 288, - 289, 290, 292, 293, 294, 295, 296, 297, 299, 300, - 301, 302, 303, 304, 306, 307, 308, 309, 310, 311, - 291, 298, 305, 312, 313, 314, 315, 316, 317, 352, - 353, 354, 355, 356, 357, 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, 0, 173, - 359, 126, 137, 360, 361, 362, 0, 437, 0, 438, - 0, 103, 102, 0, 114, 119, 144, 143, 141, 145, - 0, 138, 140, 124, 167, 142, 358, 0, 434, 436, - 0, 0, 0, 365, 0, 0, 91, 88, 0, 101, - 0, 110, 104, 112, 0, 113, 0, 89, 120, 0, - 94, 139, 125, 0, 168, 1, 435, 165, 0, 136, - 134, 0, 132, 363, 0, 0, 92, 0, 0, 439, - 105, 109, 111, 107, 115, 106, 0, 121, 97, 0, - 95, 0, 2, 8, 9, 4, 5, 6, 7, 11, - 10, 0, 0, 0, 169, 37, 36, 38, 35, 3, - 13, 31, 15, 20, 21, 0, 0, 25, 0, 39, - 0, 43, 46, 49, 54, 57, 59, 61, 63, 65, - 67, 69, 0, 29, 0, 164, 0, 0, 131, 0, - 0, 0, 0, 0, 367, 90, 93, 0, 0, 419, - 0, 0, 0, 0, 0, 0, 0, 0, 391, 400, - 404, 39, 72, 85, 0, 380, 0, 124, 383, 402, - 382, 381, 0, 384, 385, 386, 387, 388, 389, 108, - 0, 116, 0, 375, 123, 0, 0, 99, 0, 96, - 32, 33, 0, 17, 18, 0, 0, 23, 22, 0, - 173, 26, 28, 34, 0, 0, 0, 0, 0, 0, + 0, 149, 150, 148, 185, 176, 177, 179, 180, 181, + 182, 183, 184, 178, 165, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 207, 208, 209, 210, 211, 212, + 186, 187, 188, 216, 217, 218, 154, 152, 153, 151, + 157, 155, 156, 158, 159, 160, 161, 162, 163, 164, + 189, 190, 191, 228, 229, 230, 192, 193, 194, 240, + 241, 242, 204, 205, 206, 213, 214, 215, 131, 130, + 129, 0, 132, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 266, 267, 268, 269, 270, 271, 273, 274, + 275, 276, 277, 278, 280, 281, 282, 283, 284, 285, + 286, 264, 265, 272, 279, 287, 288, 289, 290, 291, + 292, 361, 293, 294, 295, 296, 297, 298, 299, 300, + 302, 303, 304, 305, 306, 307, 309, 310, 311, 312, + 313, 314, 316, 317, 318, 319, 320, 321, 301, 308, + 315, 322, 323, 324, 325, 326, 327, 362, 363, 364, + 365, 366, 367, 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, 354, + 355, 356, 357, 358, 359, 360, 0, 175, 369, 128, + 139, 370, 371, 372, 0, 447, 0, 448, 0, 105, + 104, 0, 116, 121, 146, 145, 143, 147, 0, 140, + 142, 126, 169, 144, 368, 0, 444, 446, 0, 0, + 0, 375, 0, 0, 93, 90, 0, 103, 0, 112, + 106, 114, 0, 115, 0, 91, 122, 0, 96, 141, + 127, 0, 170, 1, 445, 167, 0, 138, 136, 0, + 134, 373, 0, 0, 94, 0, 0, 449, 107, 111, + 113, 109, 117, 108, 0, 123, 99, 0, 97, 0, + 2, 10, 11, 4, 5, 6, 7, 8, 9, 13, + 12, 0, 0, 0, 171, 39, 38, 40, 37, 3, + 15, 33, 17, 22, 23, 0, 0, 27, 0, 41, + 0, 45, 48, 51, 56, 59, 61, 63, 65, 67, + 69, 71, 0, 31, 0, 166, 0, 0, 133, 0, + 0, 0, 0, 0, 377, 92, 95, 0, 0, 429, + 0, 0, 0, 0, 0, 0, 0, 0, 401, 410, + 414, 41, 74, 87, 0, 390, 0, 126, 393, 412, + 392, 391, 0, 394, 395, 396, 397, 398, 399, 110, + 0, 118, 0, 385, 125, 0, 0, 101, 0, 98, + 34, 35, 0, 19, 20, 0, 0, 25, 24, 0, + 175, 28, 30, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 70, 170, 171, 0, 166, 87, 135, - 133, 0, 0, 373, 0, 371, 366, 368, 430, 429, - 0, 421, 0, 433, 431, 0, 0, 0, 416, 417, - 390, 0, 75, 76, 78, 77, 80, 81, 82, 83, - 84, 79, 74, 0, 0, 405, 401, 403, 118, 0, - 378, 0, 122, 0, 100, 12, 0, 19, 16, 27, - 40, 41, 42, 45, 44, 47, 48, 52, 53, 50, - 51, 55, 56, 58, 60, 62, 64, 66, 68, 0, - 172, 364, 0, 374, 0, 369, 0, 0, 0, 432, - 0, 415, 0, 392, 73, 86, 117, 376, 0, 98, - 14, 0, 370, 372, 0, 424, 423, 426, 398, 411, - 409, 0, 0, 0, 0, 377, 379, 0, 0, 425, - 0, 0, 408, 0, 0, 406, 0, 0, 0, 393, - 71, 0, 427, 0, 398, 397, 399, 413, 0, 395, - 418, 394, 0, 428, 422, 407, 414, 0, 410, 420, - 412 + 0, 0, 0, 72, 172, 173, 0, 168, 89, 137, + 135, 0, 0, 383, 0, 381, 376, 378, 440, 439, + 0, 431, 0, 443, 441, 0, 0, 0, 426, 427, + 400, 0, 77, 78, 80, 79, 82, 83, 84, 85, + 86, 81, 76, 0, 0, 415, 411, 413, 120, 0, + 388, 0, 124, 0, 102, 14, 0, 21, 18, 29, + 42, 43, 44, 47, 46, 49, 50, 54, 55, 52, + 53, 57, 58, 60, 62, 64, 66, 68, 70, 0, + 174, 374, 0, 384, 0, 379, 0, 0, 0, 442, + 0, 425, 0, 402, 75, 88, 119, 386, 0, 100, + 16, 0, 380, 382, 0, 434, 433, 436, 408, 421, + 419, 0, 0, 0, 0, 387, 389, 0, 0, 435, + 0, 0, 418, 0, 0, 416, 0, 0, 0, 403, + 73, 0, 437, 0, 408, 407, 409, 423, 0, 405, + 428, 404, 0, 438, 432, 417, 424, 0, 420, 430, + 422 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -512, -512, -512, -512, -512, -512, -512, -512, -512, -512, - -512, -512, -96, -512, -263, -262, -304, -264, -205, -200, - -206, -197, -202, -196, -512, -252, -512, -282, -512, -296, - -512, 3, -512, -512, -512, 6, -512, -512, -512, -34, - -25, -27, -512, -512, -489, -512, -512, -512, -512, -110, - -512, -221, -228, -512, -512, 0, -240, -512, 12, -512, - -512, -512, -328, -330, -199, -272, -363, -512, -273, -364, - -511, -308, -512, -512, -314, -309, -512, -512, -2, -441, - -260, -512, -512, -279, -512, -512, -512, -512, -512, -512, - -512, -512, -512, -512, -512, -512, -512, 14, -512, -512 + -522, -522, -522, -522, -522, -522, -522, -522, -522, -522, + -522, -522, -103, -522, -267, -266, -296, -270, -211, -210, + -218, -209, -208, -212, -522, -259, -522, -291, -522, -309, + -522, 5, -522, -522, -522, 6, -522, -522, -522, -40, + -34, -36, -522, -522, -498, -522, -522, -522, -522, -118, + -522, -229, -236, -522, -522, 0, -245, -522, 1, -522, + -522, -522, -335, -343, -207, -285, -379, -522, -284, -375, + -521, -321, -522, -522, -329, -328, -522, -522, -16, -447, + -275, -522, -522, -294, -522, -522, -522, -522, -522, -522, + -522, -522, -522, -522, -522, -522, -522, 2, -522, -522 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 309, 310, 311, 476, 312, 313, 314, 315, 316, - 317, 318, 361, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 362, 499, 363, 463, 364, - 429, 365, 218, 386, 291, 366, 220, 221, 222, 251, - 252, 253, 223, 224, 225, 226, 227, 228, 271, 272, - 229, 230, 231, 232, 268, 333, 264, 234, 235, 236, - 340, 274, 343, 344, 434, 435, 384, 471, 368, 369, - 370, 371, 451, 534, 560, 542, 543, 544, 561, 372, - 373, 374, 545, 533, 375, 546, 567, 376, 377, 512, - 440, 507, 527, 540, 541, 378, 237, 238, 239, 248 + -1, 319, 320, 321, 486, 322, 323, 324, 325, 326, + 327, 328, 371, 330, 331, 332, 333, 334, 335, 336, + 337, 338, 339, 340, 341, 372, 509, 373, 473, 374, + 439, 375, 226, 396, 299, 376, 228, 229, 230, 259, + 260, 261, 231, 232, 233, 234, 235, 236, 279, 280, + 237, 238, 239, 240, 276, 343, 272, 242, 243, 244, + 350, 282, 353, 354, 444, 445, 394, 481, 378, 379, + 380, 381, 461, 544, 570, 552, 553, 554, 571, 382, + 383, 384, 555, 543, 385, 556, 577, 386, 387, 522, + 450, 517, 537, 550, 551, 388, 245, 246, 247, 256 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -1163,66 +1179,67 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 233, 254, 261, 217, 383, 277, 219, 392, 467, 269, - 513, 332, 431, 437, 245, 411, 412, 468, 287, 470, - 240, 242, 472, 531, 263, 422, 261, 393, 394, 254, - 285, 380, 263, 556, 517, 401, 518, 559, 531, 286, - 334, 263, 559, 379, 381, 247, -30, 385, 395, 276, - 413, 414, 396, 341, 241, 246, 243, 445, 473, 447, - 423, 452, 453, 454, 455, 456, 457, 458, 459, 460, - 461, 334, 288, 250, 334, 289, 506, 335, 290, 346, - 462, 469, 426, 336, 338, 428, 398, 475, 528, 529, - 339, 562, 399, 464, 464, 464, 258, 464, 383, 477, - 383, 437, 256, 383, 249, 257, 516, 487, 488, 489, - 490, 388, 464, 261, 389, 465, 566, 479, 504, 341, - 464, 505, 341, 509, 504, 409, 410, 522, 213, 214, - 215, 404, 405, 406, 407, 263, 408, 415, 416, 464, - 511, 464, 537, 437, 483, 484, 508, 485, 486, 467, - 510, 491, 492, 267, 273, 536, 283, 278, 284, 334, - 337, 387, 397, 402, 345, 341, 417, 319, 418, 419, - 420, 421, 424, 427, 433, 438, 439, 441, 270, 442, - 443, 514, 515, 448, 474, 446, 449, 383, -29, 478, - 524, -24, 547, 503, 554, 568, 450, 500, 520, 538, - 464, -396, 467, 521, 548, 390, 391, 549, 552, 553, - 341, 358, 493, 495, 557, 558, 530, 570, 494, 497, - 281, 569, 255, 496, 403, 280, 498, 282, 244, 430, - 262, 530, 523, 502, 525, 555, 383, 233, 319, 564, - 217, 319, 551, 219, 275, 565, 279, 526, 539, 0, - 255, 266, 341, 0, 255, 550, 563, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 342, 0, 383, 0, 367, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 532, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 261, 0, 532, 0, 480, 481, - 482, 319, 319, 319, 319, 319, 319, 319, 319, 319, - 319, 319, 319, 319, 319, 319, 319, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 342, 432, 0, 342, 0, 0, 0, 0, 0, 0, + 241, 262, 269, 393, 402, 225, 227, 477, 285, 277, + 447, 478, 342, 480, 523, 441, 482, 253, 250, 403, + 404, 295, 421, 422, 541, 293, 269, 271, 432, 262, + 221, 222, 223, 566, 294, 271, 411, 569, -32, 541, + 405, 248, 569, 284, 406, 271, 389, 391, 249, 419, + 420, 344, 390, 351, 455, 251, 457, 423, 424, 356, + 254, 483, 255, 433, 462, 463, 464, 465, 466, 467, + 468, 469, 470, 471, 344, 516, 264, 344, 417, 265, + 418, 395, 257, 472, 479, 436, 296, 345, 438, 297, + 258, 348, 298, 346, 474, 521, 487, 349, 447, 393, + 526, 393, 408, 485, 393, 538, 539, 572, 409, 474, + 266, 474, 474, 474, 398, 269, 474, 399, 489, 475, + 576, 351, 425, 426, 351, 497, 498, 499, 500, 514, + 474, 514, 515, 519, 532, 414, 415, 416, 271, 527, + 447, 528, 275, 518, 281, 474, 547, 520, 477, 546, + 493, 494, 286, 495, 496, 501, 502, 291, 292, 344, + 347, 397, 355, 427, 407, 412, 428, 351, 329, 429, + 430, 431, 434, 437, 443, 484, 448, 449, 451, 452, + 453, 456, 524, 525, 278, 458, 459, -31, 393, 578, + 460, 488, 510, -26, 534, 474, 530, 548, 513, -406, + 531, 477, 557, 558, 559, 563, 562, 564, 400, 401, + 568, 505, 351, 540, 368, 567, 503, 580, 504, 579, + 508, 506, 289, 507, 288, 252, 290, 413, 540, 533, + 263, 440, 565, 535, 574, 512, 575, 393, 270, 561, + 287, 329, 536, 549, 329, 241, 0, 274, 0, 0, + 225, 227, 283, 573, 351, 0, 560, 0, 263, 0, + 0, 0, 263, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 393, 0, 0, + 0, 0, 352, 0, 0, 0, 377, 0, 0, 0, + 0, 0, 0, 542, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 269, 0, 542, 0, + 0, 490, 491, 492, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, 329, 329, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 367, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 342, 0, 0, 0, + 352, 442, 0, 352, 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, 352, 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, 342, 0, 0, 0, 0, 0, 0, 0, 0, - 367, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 367, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 352, 0, 0, 0, 0, 0, 0, 0, 0, + 377, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 377, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 342, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 352, 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, 367, 0, 0, - 0, 0, 367, 367, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 367, 0, 0, - 0, 0, 262, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 367, 0, 0, 0, 367, 0, - 0, 0, 0, 367, 0, 0, 0, 367, 0, 0, - 0, 0, 0, 0, 265, 0, 367, 1, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 0, 0, 0, 0, 0, 0, 0, 377, 0, 0, + 0, 0, 377, 377, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 377, 0, 0, + 0, 0, 270, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 377, 0, 0, 0, 377, 0, + 0, 0, 0, 377, 0, 0, 0, 377, 0, 0, + 0, 0, 0, 0, 273, 0, 377, 1, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 14, 15, 16, 17, 18, 19, 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, @@ -1241,16 +1258,17 @@ static const yytype_int16 yytable[] = 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, 0, 0, 210, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 0, 0, 218, 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, 211, 212, 213, 214, 215, 216, 1, + 0, 0, 0, 219, 220, 221, 222, 223, 224, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 347, 348, 349, 0, 350, 351, 352, 353, 354, 355, - 356, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 12, 13, 357, 358, 359, 0, 360, 361, 362, 363, + 364, 365, 366, 14, 15, 16, 17, 18, 19, 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, @@ -1269,16 +1287,17 @@ static const yytype_int16 yytable[] = 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, 357, - 292, 210, 293, 294, 295, 296, 297, 298, 299, 300, - 0, 0, 301, 302, 0, 0, 0, 0, 0, 0, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 367, 300, 218, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 0, 0, 311, 312, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 303, 0, 0, 0, 358, 359, 0, 0, 0, - 0, 360, 305, 306, 307, 308, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 211, 212, 213, 214, 215, - 216, 1, 2, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 347, 348, 349, 0, 350, 351, 352, 353, - 354, 355, 356, 12, 13, 14, 15, 16, 17, 18, + 0, 313, 0, 0, 0, 368, 369, 0, 0, 0, + 0, 370, 315, 316, 317, 318, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 219, 220, 221, 222, 223, + 224, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 357, 358, 359, 0, 360, 361, + 362, 363, 364, 365, 366, 14, 15, 16, 17, 18, 19, 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, @@ -1298,15 +1317,16 @@ static const yytype_int16 yytable[] = 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, 357, 292, 210, 293, 294, 295, 296, 297, 298, - 299, 300, 0, 0, 301, 302, 0, 0, 0, 0, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 367, + 300, 218, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 0, 0, 311, 312, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 303, 0, 0, 0, 358, 466, 0, - 0, 0, 0, 360, 305, 306, 307, 308, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 211, 212, 213, - 214, 215, 216, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 347, 348, 349, 0, 350, 351, - 352, 353, 354, 355, 356, 12, 13, 14, 15, 16, + 0, 0, 0, 313, 0, 0, 0, 368, 476, 0, + 0, 0, 0, 370, 315, 316, 317, 318, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 219, 220, 221, + 222, 223, 224, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 357, 358, 359, 0, + 360, 361, 362, 363, 364, 365, 366, 14, 15, 16, 17, 18, 19, 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, @@ -1326,15 +1346,16 @@ static const yytype_int16 yytable[] = 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, 357, 292, 210, 293, 294, 295, 296, - 297, 298, 299, 300, 0, 0, 301, 302, 0, 0, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 367, 300, 218, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 0, 0, 311, 312, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 303, 0, 0, 0, 358, - 0, 0, 0, 0, 0, 360, 305, 306, 307, 308, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 211, - 212, 213, 214, 215, 216, 1, 2, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 347, 348, 349, 0, - 350, 351, 352, 353, 354, 355, 356, 12, 13, 14, + 0, 0, 0, 0, 0, 313, 0, 0, 0, 368, + 0, 0, 0, 0, 0, 370, 315, 316, 317, 318, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 219, + 220, 221, 222, 223, 224, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 357, 358, + 359, 0, 360, 361, 362, 363, 364, 365, 366, 14, 15, 16, 17, 18, 19, 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, @@ -1354,16 +1375,17 @@ static const yytype_int16 yytable[] = 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, 357, 292, 210, 293, 294, - 295, 296, 297, 298, 299, 300, 0, 0, 301, 302, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 367, 300, 218, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 0, 0, 311, 312, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 303, 0, 0, - 0, 278, 0, 0, 0, 0, 0, 360, 305, 306, - 307, 308, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 211, 212, 213, 214, 215, 216, 1, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 347, 348, - 349, 0, 350, 351, 352, 353, 354, 355, 356, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 0, 0, 0, 0, 0, 0, 0, 313, 0, 0, + 0, 286, 0, 0, 0, 0, 0, 370, 315, 316, + 317, 318, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 219, 220, 221, 222, 223, 224, 1, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 357, 358, 359, 0, 360, 361, 362, 363, 364, 365, + 366, 14, 15, 16, 17, 18, 19, 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, @@ -1382,16 +1404,17 @@ static const yytype_int16 yytable[] = 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, 357, 292, 210, - 293, 294, 295, 296, 297, 298, 299, 300, 0, 0, - 301, 302, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 303, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 360, - 305, 306, 307, 308, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 211, 212, 213, 214, 215, 216, 1, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 367, 300, 218, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 0, 0, + 311, 312, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 313, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 370, + 315, 316, 317, 318, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 219, 220, 221, 222, 223, 224, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 12, 13, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 14, 15, 16, 17, 18, 19, 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, @@ -1410,16 +1433,17 @@ static const yytype_int16 yytable[] = 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, 0, - 292, 210, 293, 294, 295, 296, 297, 298, 299, 300, - 0, 0, 301, 302, 0, 0, 0, 0, 0, 0, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 0, 300, 218, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 0, 0, 311, 312, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 303, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 360, 305, 306, 307, 308, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 211, 212, 213, 214, 215, - 216, 1, 2, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 12, 13, 14, 15, 16, 17, 18, + 0, 313, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 370, 315, 316, 317, 318, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 219, 220, 221, 222, 223, + 224, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 14, 15, 16, 17, 18, 19, 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, @@ -1439,13 +1463,97 @@ static const yytype_int16 yytable[] = 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, 0, 0, 210, 0, 0, 0, 0, 0, 0, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 0, + 0, 218, 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, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 0, 0, 0, 0, 0, 219, 220, 221, + 222, 223, 224, 14, 15, 16, 17, 18, 19, 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, 0, 300, 218, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 0, 0, 311, 312, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 313, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 315, 316, 317, 318, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 219, 220, 221, 222, 223, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 14, 15, 16, 17, 18, 19, + 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, 0, 267, + 218, 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, 1, 2, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 0, 0, 0, 0, 0, 211, 212, 213, - 214, 215, 216, 12, 13, 14, 15, 16, 17, 18, + 0, 0, 268, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 219, 220, 221, 222, + 223, 0, 0, 0, 0, 0, 0, 14, 15, 16, + 17, 18, 19, 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, 0, 0, 218, 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, + 446, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 0, 0, 0, 0, 0, 219, + 220, 221, 222, 223, 0, 14, 15, 16, 17, 18, 19, 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, @@ -1465,21 +1573,97 @@ static const yytype_int16 yytable[] = 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, 0, 292, 210, 293, 294, 295, 296, 297, 298, - 299, 300, 0, 0, 301, 302, 0, 0, 0, 0, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 0, + 0, 218, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 303, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 305, 306, 307, 308, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 211, 212, 213, - 214, 215, 1, 2, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 12, 13, 14, 15, 16, 17, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 511, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 0, 0, 0, 0, 0, 219, 220, 221, + 222, 223, 0, 14, 15, 16, 17, 18, 19, 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, 0, 0, 218, + 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, 529, 1, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 0, 0, 0, 0, 0, 219, 220, 221, 222, 223, + 0, 14, 15, 16, 17, 18, 19, 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, 0, 0, 218, 0, 0, + 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 219, 220, 221, 222, 223, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 0, 0, 0, 0, + 0, 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, 0, 300, 218, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 0, + 0, 311, 312, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 313, 0, 0, 0, 392, 545, 0, 0, 0, 0, + 0, 315, 316, 317, 318, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 15, 16, 17, 18, 19, 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, + 28, 29, 30, 31, 32, 33, 34, 35, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 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, + 0, 0, 0, 0, 0, 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, @@ -1493,45 +1677,75 @@ static const yytype_int16 yytable[] = 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, 0, 259, 210, 0, 0, 0, 0, 0, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 0, 300, 218, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 0, 0, 311, 312, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 313, 0, 0, 314, 0, 0, + 0, 0, 0, 0, 0, 315, 316, 317, 318, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 0, 0, 0, 0, 0, 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, 0, 300, 218, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 0, 0, 311, + 312, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 313, 0, + 0, 0, 392, 0, 0, 0, 0, 0, 0, 315, + 316, 317, 318, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 260, 1, 2, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 0, 0, 211, 212, - 213, 214, 215, 0, 0, 0, 0, 12, 13, 14, - 15, 16, 17, 18, 19, 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, 0, 0, 210, 0, 0, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 0, 0, + 0, 0, 0, 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, 0, 300, + 218, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 0, 0, 311, 312, 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, 436, 0, 1, 2, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 0, 0, 0, 0, 0, - 0, 211, 212, 213, 214, 215, 12, 13, 14, 15, + 0, 0, 313, 0, 0, 435, 0, 0, 0, 0, + 0, 0, 0, 315, 316, 317, 318, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 17, 18, 19, 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, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 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, + 66, 67, 0, 0, 0, 0, 0, 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, @@ -1545,326 +1759,152 @@ static const yytype_int16 yytable[] = 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, 0, 0, 210, 0, 0, 0, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 0, 300, 218, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 0, 0, 311, 312, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 313, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 454, 315, 316, 317, + 318, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 0, 0, 0, 0, + 0, 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, 0, 300, 218, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 0, + 0, 311, 312, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 313, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 315, 316, 317, 318, 0, 0, 0, 0, 0, + 0, 0, 0, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 0, 0, 0, 0, + 0, 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, 410, 0, 300, 218, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 0, + 0, 311, 312, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 501, 0, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 0, 0, 0, 0, 0, 0, - 211, 212, 213, 214, 215, 12, 13, 14, 15, 16, - 17, 18, 19, 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, 0, 0, 210, 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, - 519, 0, 1, 2, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 0, 0, 0, 0, 0, 0, 211, - 212, 213, 214, 215, 12, 13, 14, 15, 16, 17, - 18, 19, 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, 0, 0, 210, 0, 0, 0, 4, 5, - 6, 7, 8, 9, 10, 11, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 211, 212, - 213, 214, 215, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 0, 0, 0, 0, 0, - 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, 0, 292, 210, 293, 294, - 295, 296, 297, 298, 299, 300, 0, 0, 301, 302, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 303, 0, 0, - 0, 382, 535, 0, 0, 0, 0, 0, 305, 306, - 307, 308, 4, 5, 6, 7, 8, 9, 10, 11, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 0, - 0, 0, 0, 0, 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, 0, - 292, 210, 293, 294, 295, 296, 297, 298, 299, 300, - 0, 0, 301, 302, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 303, 0, 0, 304, 0, 0, 0, 0, 0, - 0, 0, 305, 306, 307, 308, 4, 5, 6, 7, - 8, 9, 10, 11, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 0, 0, 0, 0, 0, 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, 0, 292, 210, 293, 294, 295, 296, - 297, 298, 299, 300, 0, 0, 301, 302, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 303, 0, 0, 0, 382, - 0, 0, 0, 0, 0, 0, 305, 306, 307, 308, - 4, 5, 6, 7, 8, 9, 10, 11, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 0, 0, 0, - 0, 0, 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, 0, 292, 210, - 293, 294, 295, 296, 297, 298, 299, 300, 0, 0, - 301, 302, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 303, - 0, 0, 425, 0, 0, 0, 0, 0, 0, 0, - 305, 306, 307, 308, 4, 5, 6, 7, 8, 9, - 10, 11, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 0, 0, 0, 0, 0, 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, 0, 292, 210, 293, 294, 295, 296, 297, 298, - 299, 300, 0, 0, 301, 302, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 303, 4, 5, 6, 7, 8, 9, - 10, 11, 0, 444, 305, 306, 307, 308, 0, 0, - 0, 0, 0, 0, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 0, 0, 0, 0, 0, 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, 0, 292, 210, 293, 294, 295, 296, 297, 298, - 299, 300, 0, 0, 301, 302, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 303, 4, 5, 6, 7, 8, 9, - 10, 11, 0, 0, 305, 306, 307, 308, 0, 0, - 0, 0, 0, 0, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 0, 0, 0, 0, 0, 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, - 400, 0, 292, 210, 293, 294, 295, 296, 297, 298, - 299, 300, 0, 0, 301, 302, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 303, 4, 5, 6, 7, 8, 9, - 10, 11, 0, 0, 305, 306, 307, 308, 0, 0, - 0, 0, 0, 0, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 0, 0, 0, 0, 0, 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, 0, 0, 210 + 313, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 315, 316, 317, 318, 0, 0, 0, 0, 0, + 0, 0, 0, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 0, 0, 0, 0, + 0, 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, 0, 0, 218 }; static const yytype_int16 yycheck[] = { - 0, 222, 230, 0, 286, 245, 0, 303, 372, 55, - 451, 263, 340, 343, 224, 238, 239, 380, 258, 382, - 255, 224, 385, 512, 257, 243, 254, 236, 237, 250, - 255, 264, 257, 544, 260, 317, 262, 548, 527, 264, - 257, 257, 553, 283, 284, 265, 255, 264, 257, 265, - 273, 274, 261, 274, 255, 265, 259, 353, 386, 355, - 278, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 257, 259, 262, 257, 262, 440, 256, 265, 265, - 264, 264, 334, 262, 256, 337, 256, 256, 256, 256, - 262, 256, 262, 262, 262, 262, 224, 262, 380, 395, - 382, 431, 262, 385, 256, 265, 469, 411, 412, 413, - 414, 262, 262, 341, 265, 265, 557, 399, 262, 340, - 262, 265, 343, 265, 262, 234, 235, 265, 281, 282, - 283, 270, 271, 272, 267, 257, 269, 240, 241, 262, - 263, 262, 263, 473, 407, 408, 442, 409, 410, 513, - 446, 415, 416, 224, 259, 518, 224, 259, 224, 257, - 264, 224, 256, 255, 265, 386, 277, 263, 276, 275, - 242, 244, 258, 224, 224, 265, 265, 255, 224, 255, - 265, 463, 464, 263, 224, 255, 255, 469, 255, 224, - 223, 256, 224, 433, 17, 558, 260, 258, 258, 255, - 262, 259, 566, 499, 256, 301, 302, 260, 265, 256, - 431, 259, 417, 419, 259, 264, 512, 260, 418, 421, - 254, 265, 222, 420, 320, 250, 422, 254, 216, 339, - 230, 527, 504, 432, 507, 543, 518, 237, 334, 553, - 237, 337, 538, 237, 244, 554, 248, 507, 527, -1, - 250, 237, 473, -1, 254, 537, 552, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 274, -1, 558, -1, 278, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 512, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 532, -1, 527, -1, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 421, 422, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 340, 341, -1, 343, -1, -1, -1, -1, -1, -1, + 0, 230, 238, 294, 313, 0, 0, 382, 253, 57, + 353, 390, 271, 392, 461, 350, 395, 232, 232, 246, + 247, 266, 248, 249, 522, 265, 262, 267, 253, 258, + 291, 292, 293, 554, 274, 267, 327, 558, 265, 537, + 267, 265, 563, 275, 271, 267, 291, 292, 265, 244, + 245, 267, 274, 282, 363, 269, 365, 283, 284, 275, + 275, 396, 275, 288, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 267, 450, 272, 267, 277, 275, + 279, 274, 266, 274, 274, 344, 269, 266, 347, 272, + 272, 266, 275, 272, 272, 273, 405, 272, 441, 390, + 479, 392, 266, 266, 395, 266, 266, 266, 272, 272, + 232, 272, 272, 272, 272, 351, 272, 275, 409, 275, + 567, 350, 250, 251, 353, 421, 422, 423, 424, 272, + 272, 272, 275, 275, 275, 280, 281, 282, 267, 270, + 483, 272, 232, 452, 269, 272, 273, 456, 523, 528, + 417, 418, 269, 419, 420, 425, 426, 232, 232, 267, + 274, 232, 275, 287, 266, 265, 286, 396, 271, 285, + 252, 254, 268, 232, 232, 232, 275, 275, 265, 265, + 275, 265, 473, 474, 232, 273, 265, 265, 479, 568, + 270, 232, 268, 266, 231, 272, 268, 265, 443, 269, + 509, 576, 232, 266, 270, 266, 275, 19, 311, 312, + 274, 429, 441, 522, 269, 269, 427, 270, 428, 275, + 432, 430, 262, 431, 258, 224, 262, 330, 537, 514, + 230, 349, 553, 517, 563, 442, 564, 528, 238, 548, + 256, 344, 517, 537, 347, 245, -1, 245, -1, -1, + 245, 245, 252, 562, 483, -1, 547, -1, 258, -1, + -1, -1, 262, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 568, -1, -1, + -1, -1, 282, -1, -1, -1, 286, -1, -1, -1, + -1, -1, -1, 522, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 542, -1, 537, -1, + -1, 414, 415, 416, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 372, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 386, -1, -1, -1, + 350, 351, -1, 353, -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, 382, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 396, -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, 431, -1, -1, -1, -1, -1, -1, -1, -1, - 440, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 451, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 441, -1, -1, -1, -1, -1, -1, -1, -1, + 450, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 461, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 473, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 483, -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, 507, -1, -1, - -1, -1, 512, 513, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 527, -1, -1, - -1, -1, 532, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 544, -1, -1, -1, 548, -1, - -1, -1, -1, 553, -1, -1, -1, 557, -1, -1, - -1, -1, -1, -1, 0, -1, 566, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + -1, -1, -1, -1, -1, -1, -1, 517, -1, -1, + -1, -1, 522, 523, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 537, -1, -1, + -1, -1, 542, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 554, -1, -1, -1, 558, -1, + -1, -1, -1, 563, -1, -1, -1, 567, -1, -1, + -1, -1, -1, -1, 0, -1, 576, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 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, @@ -1883,15 +1923,16 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 225, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, -1, -1, 233, -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, 279, 280, 281, 282, 283, 284, 3, + -1, -1, -1, 289, 290, 291, 292, 293, 294, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, -1, 18, 19, 20, 21, 22, 23, + 14, 15, 16, 17, 18, -1, 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, @@ -1913,13 +1954,14 @@ static const yytype_int16 yycheck[] = 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, - -1, -1, 236, 237, -1, -1, -1, -1, -1, -1, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + -1, -1, 246, 247, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 255, -1, -1, -1, 259, 260, -1, -1, -1, - -1, 265, 266, 267, 268, 269, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 279, 280, 281, 282, 283, - 284, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, -1, 18, 19, 20, 21, + -1, 265, -1, -1, -1, 269, 270, -1, -1, -1, + -1, 275, 276, 277, 278, 279, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 289, 290, 291, 292, 293, + 294, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, -1, 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, @@ -1941,13 +1983,14 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 236, 237, -1, -1, -1, -1, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, -1, -1, 246, 247, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 255, -1, -1, -1, 259, 260, -1, - -1, -1, -1, 265, 266, 267, 268, 269, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 279, 280, 281, - 282, 283, 284, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, -1, 18, 19, + -1, -1, -1, 265, -1, -1, -1, 269, 270, -1, + -1, -1, -1, 275, 276, 277, 278, 279, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 289, 290, 291, + 292, 293, 294, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, -1, 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, @@ -1969,14 +2012,15 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 236, 237, -1, -1, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, -1, -1, 246, 247, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 255, -1, -1, -1, 259, - -1, -1, -1, -1, -1, 265, 266, 267, 268, 269, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 279, - 280, 281, 282, 283, 284, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, -1, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, -1, -1, -1, 265, -1, -1, -1, 269, + -1, -1, -1, -1, -1, 275, 276, 277, 278, 279, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 289, + 290, 291, 292, 293, 294, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, -1, 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, @@ -1997,14 +2041,15 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 236, 237, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, -1, -1, 246, 247, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 255, -1, -1, - -1, 259, -1, -1, -1, -1, -1, 265, 266, 267, - 268, 269, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 279, 280, 281, 282, 283, 284, 3, 4, 5, + -1, -1, -1, -1, -1, -1, -1, 265, -1, -1, + -1, 269, -1, -1, -1, -1, -1, 275, 276, 277, + 278, 279, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 289, 290, 291, 292, 293, 294, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, -1, 18, 19, 20, 21, 22, 23, 24, 25, + 16, 17, 18, -1, 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, @@ -2025,15 +2070,16 @@ static const yytype_int16 yycheck[] = 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, -1, -1, - 236, 237, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 255, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, -1, -1, + 246, 247, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 265, - 266, 267, 268, 269, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 279, 280, 281, 282, 283, 284, 3, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 275, + 276, 277, 278, 279, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 289, 290, 291, 292, 293, 294, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 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, @@ -2052,16 +2098,17 @@ static const yytype_int16 yycheck[] = 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, -1, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - -1, -1, 236, 237, -1, -1, -1, -1, -1, -1, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, -1, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + -1, -1, 246, 247, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 255, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 265, 266, 267, 268, 269, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 279, 280, 281, 282, 283, - 284, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 25, 26, 27, 28, 29, 30, 31, + -1, 265, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 275, 276, 277, 278, 279, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 289, 290, 291, 292, 293, + 294, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 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, @@ -2081,199 +2128,19 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 225, -1, -1, -1, -1, -1, -1, + 222, 223, 224, 225, 226, 227, 228, 229, 230, -1, + -1, 233, -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, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, -1, -1, -1, -1, -1, 279, 280, 281, - 282, 283, 284, 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, -1, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, -1, -1, 236, 237, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 255, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 266, 267, 268, 269, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 279, 280, 281, - 282, 283, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 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, -1, 224, 225, -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, 265, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, -1, -1, 279, 280, - 281, 282, 283, -1, -1, -1, -1, 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, -1, -1, 225, -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, 260, -1, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, -1, -1, -1, -1, -1, - -1, 279, 280, 281, 282, 283, 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, -1, -1, 225, -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, 260, -1, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, -1, -1, -1, -1, -1, -1, - 279, 280, 281, 282, 283, 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, -1, -1, 225, -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, - 260, -1, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, -1, -1, -1, -1, -1, -1, 279, - 280, 281, 282, 283, 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, -1, -1, 225, -1, -1, -1, 6, 7, - 8, 9, 10, 11, 12, 13, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 279, 280, - 281, 282, 283, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, -1, -1, -1, -1, -1, - 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, -1, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, -1, -1, 236, 237, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 255, -1, -1, - -1, 259, 260, -1, -1, -1, -1, -1, 266, 267, - 268, 269, 6, 7, 8, 9, 10, 11, 12, 13, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, -1, -1, -1, -1, -1, 289, 290, 291, + 292, 293, 294, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, -1, - -1, -1, -1, -1, 78, 79, 80, 81, 82, 83, + 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, @@ -2287,170 +2154,17 @@ static const yytype_int16 yycheck[] = 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, -1, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - -1, -1, 236, 237, -1, -1, -1, -1, -1, -1, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, -1, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + -1, -1, 246, 247, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 255, -1, -1, 258, -1, -1, -1, -1, -1, - -1, -1, 266, 267, 268, 269, 6, 7, 8, 9, - 10, 11, 12, 13, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, -1, -1, -1, -1, -1, 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, -1, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, -1, -1, 236, 237, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 255, -1, -1, -1, 259, - -1, -1, -1, -1, -1, -1, 266, 267, 268, 269, - 6, 7, 8, 9, 10, 11, 12, 13, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, -1, -1, -1, - -1, -1, 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, -1, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, -1, -1, - 236, 237, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 255, - -1, -1, 258, -1, -1, -1, -1, -1, -1, -1, - 266, 267, 268, 269, 6, 7, 8, 9, 10, 11, - 12, 13, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, -1, -1, -1, -1, -1, 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, -1, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, -1, -1, 236, 237, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 255, 6, 7, 8, 9, 10, 11, - 12, 13, -1, 265, 266, 267, 268, 269, -1, -1, - -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, -1, -1, -1, -1, -1, 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, -1, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, -1, -1, 236, 237, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 255, 6, 7, 8, 9, 10, 11, - 12, 13, -1, -1, 266, 267, 268, 269, -1, -1, - -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, -1, -1, -1, -1, -1, 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, -1, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, -1, -1, 236, 237, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 255, 6, 7, 8, 9, 10, 11, - 12, 13, -1, -1, 266, 267, 268, 269, -1, -1, - -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, -1, -1, -1, -1, -1, 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, -1, -1, 225 -}; - - /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ -static const yytype_uint16 yystos[] = -{ - 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 25, 26, 27, 28, 29, 30, 31, 32, + -1, 265, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 276, 277, 278, 279, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 289, 290, 291, 292, 293, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 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, @@ -2470,115 +2184,466 @@ static const yytype_uint16 yystos[] = 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, - 225, 279, 280, 281, 282, 283, 284, 319, 320, 323, - 324, 325, 326, 330, 331, 332, 333, 334, 335, 338, - 339, 340, 341, 343, 345, 346, 347, 384, 385, 386, - 255, 255, 224, 259, 346, 224, 265, 265, 387, 256, - 262, 327, 328, 329, 339, 343, 262, 265, 224, 224, - 265, 340, 343, 257, 344, 0, 385, 224, 342, 55, - 224, 336, 337, 259, 349, 343, 265, 344, 259, 366, - 328, 327, 329, 224, 224, 255, 264, 344, 259, 262, - 265, 322, 224, 226, 227, 228, 229, 230, 231, 232, - 233, 236, 237, 255, 258, 266, 267, 268, 269, 289, - 290, 291, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 343, 257, 256, 262, 264, 256, 262, - 348, 339, 343, 350, 351, 265, 265, 14, 15, 16, - 18, 19, 20, 21, 22, 23, 24, 223, 259, 260, - 265, 300, 313, 315, 317, 319, 323, 343, 356, 357, - 358, 359, 367, 368, 369, 372, 375, 376, 383, 344, - 264, 344, 259, 315, 354, 264, 321, 224, 262, 265, - 300, 300, 317, 236, 237, 257, 261, 256, 256, 262, - 222, 315, 255, 300, 270, 271, 272, 267, 269, 234, - 235, 238, 239, 273, 274, 240, 241, 277, 276, 275, - 242, 244, 243, 278, 258, 258, 313, 224, 313, 318, - 337, 350, 343, 224, 352, 353, 260, 351, 265, 265, - 378, 255, 255, 265, 265, 317, 255, 317, 263, 255, - 260, 360, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 264, 316, 262, 265, 260, 357, 354, 264, - 354, 355, 354, 350, 224, 256, 292, 317, 224, 315, - 300, 300, 300, 302, 302, 303, 303, 304, 304, 304, - 304, 305, 305, 306, 307, 308, 309, 310, 311, 314, - 258, 260, 352, 344, 262, 265, 357, 379, 317, 265, - 317, 263, 377, 367, 315, 315, 354, 260, 262, 260, - 258, 317, 265, 353, 223, 356, 368, 380, 256, 256, - 317, 332, 339, 371, 361, 260, 354, 263, 255, 371, - 381, 382, 363, 364, 365, 370, 373, 224, 256, 260, - 315, 317, 265, 256, 17, 359, 358, 259, 264, 358, - 362, 366, 256, 317, 362, 363, 367, 374, 354, 265, - 260 + 223, 224, 225, 226, 227, 228, 229, 230, -1, 232, + 233, -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, 275, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 289, 290, 291, 292, + 293, -1, -1, -1, -1, -1, -1, 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, -1, -1, 233, -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, + 270, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, -1, -1, -1, -1, -1, 289, + 290, 291, 292, 293, -1, 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, -1, + -1, 233, -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, 270, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, -1, -1, -1, -1, -1, 289, 290, 291, + 292, 293, -1, 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, -1, -1, 233, + -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, 270, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + -1, -1, -1, -1, -1, 289, 290, 291, 292, 293, + -1, 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, -1, -1, 233, -1, -1, + -1, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 289, 290, 291, 292, 293, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, -1, -1, -1, -1, + -1, 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, -1, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, -1, + -1, 246, 247, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 265, -1, -1, -1, 269, 270, -1, -1, -1, -1, + -1, 276, 277, 278, 279, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + -1, -1, -1, -1, -1, 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, + -1, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, -1, -1, 246, 247, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 265, -1, -1, 268, -1, -1, + -1, -1, -1, -1, -1, 276, 277, 278, 279, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, -1, -1, -1, -1, -1, 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, -1, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, -1, -1, 246, + 247, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 265, -1, + -1, -1, 269, -1, -1, -1, -1, -1, -1, 276, + 277, 278, 279, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, -1, -1, + -1, -1, -1, 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, -1, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, -1, -1, 246, 247, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 265, -1, -1, 268, -1, -1, -1, -1, + -1, -1, -1, 276, 277, 278, 279, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, -1, -1, -1, -1, -1, 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, -1, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, -1, -1, 246, 247, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 265, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 275, 276, 277, 278, + 279, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, -1, -1, -1, -1, + -1, 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, -1, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, -1, + -1, 246, 247, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 265, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 276, 277, 278, 279, -1, -1, -1, -1, -1, + -1, -1, -1, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, -1, -1, -1, -1, + -1, 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, -1, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, -1, + -1, 246, 247, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 265, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 276, 277, 278, 279, -1, -1, -1, -1, -1, + -1, -1, -1, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, -1, -1, -1, -1, + -1, 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, -1, -1, 233 +}; + + /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint16 yystos[] = +{ + 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 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, 233, 289, + 290, 291, 292, 293, 294, 329, 330, 333, 334, 335, + 336, 340, 341, 342, 343, 344, 345, 348, 349, 350, + 351, 353, 355, 356, 357, 394, 395, 396, 265, 265, + 232, 269, 356, 232, 275, 275, 397, 266, 272, 337, + 338, 339, 349, 353, 272, 275, 232, 232, 275, 350, + 353, 267, 354, 0, 395, 232, 352, 57, 232, 346, + 347, 269, 359, 353, 275, 354, 269, 376, 338, 337, + 339, 232, 232, 265, 274, 354, 269, 272, 275, 332, + 232, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 246, 247, 265, 268, 276, 277, 278, 279, 299, + 300, 301, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 353, 267, 266, 272, 274, 266, 272, + 358, 349, 353, 360, 361, 275, 275, 16, 17, 18, + 20, 21, 22, 23, 24, 25, 26, 231, 269, 270, + 275, 310, 323, 325, 327, 329, 333, 353, 366, 367, + 368, 369, 377, 378, 379, 382, 385, 386, 393, 354, + 274, 354, 269, 325, 364, 274, 331, 232, 272, 275, + 310, 310, 327, 246, 247, 267, 271, 266, 266, 272, + 230, 325, 265, 310, 280, 281, 282, 277, 279, 244, + 245, 248, 249, 283, 284, 250, 251, 287, 286, 285, + 252, 254, 253, 288, 268, 268, 323, 232, 323, 328, + 347, 360, 353, 232, 362, 363, 270, 361, 275, 275, + 388, 265, 265, 275, 275, 327, 265, 327, 273, 265, + 270, 370, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 274, 326, 272, 275, 270, 367, 364, 274, + 364, 365, 364, 360, 232, 266, 302, 327, 232, 325, + 310, 310, 310, 312, 312, 313, 313, 314, 314, 314, + 314, 315, 315, 316, 317, 318, 319, 320, 321, 324, + 268, 270, 362, 354, 272, 275, 367, 389, 327, 275, + 327, 273, 387, 377, 325, 325, 364, 270, 272, 270, + 268, 327, 275, 363, 231, 366, 378, 390, 266, 266, + 327, 342, 349, 381, 371, 270, 364, 273, 265, 381, + 391, 392, 373, 374, 375, 380, 383, 232, 266, 270, + 325, 327, 275, 266, 19, 369, 368, 269, 274, 368, + 372, 376, 266, 327, 372, 373, 377, 384, 364, 275, + 270 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint16 yyr1[] = { - 0, 288, 289, 290, 290, 290, 290, 290, 290, 290, - 290, 290, 290, 291, 291, 291, 291, 291, 291, 292, - 293, 294, 295, 295, 296, 296, 297, 297, 298, 299, - 299, 300, 300, 300, 300, 301, 301, 301, 301, 302, - 302, 302, 302, 303, 303, 303, 304, 304, 304, 305, - 305, 305, 305, 305, 306, 306, 306, 307, 307, 308, - 308, 309, 309, 310, 310, 311, 311, 312, 312, 313, - 314, 313, 315, 315, 316, 316, 316, 316, 316, 316, - 316, 316, 316, 316, 316, 317, 317, 318, 319, 319, - 319, 319, 319, 319, 319, 319, 319, 321, 320, 322, - 322, 323, 324, 324, 325, 325, 326, 327, 327, 328, - 328, 328, 328, 329, 330, 330, 330, 330, 330, 331, - 331, 331, 331, 331, 332, 332, 333, 334, 334, 334, - 334, 335, 336, 336, 337, 337, 337, 338, 339, 339, - 340, 340, 340, 340, 340, 340, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 342, 342, 343, 343, 344, - 344, 344, 344, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, - 346, 346, 346, 348, 347, 349, 347, 350, 350, 351, - 351, 352, 352, 353, 353, 354, 354, 354, 355, 355, - 356, 357, 357, 358, 358, 358, 358, 358, 358, 358, - 359, 360, 361, 359, 362, 362, 364, 363, 365, 363, - 366, 366, 367, 367, 368, 368, 369, 370, 370, 371, - 371, 373, 372, 374, 374, 375, 375, 377, 376, 378, - 376, 379, 376, 380, 380, 381, 381, 382, 382, 383, - 383, 383, 383, 383, 384, 384, 385, 385, 387, 386 + 0, 298, 299, 300, 300, 300, 300, 300, 300, 300, + 300, 300, 300, 300, 300, 301, 301, 301, 301, 301, + 301, 302, 303, 304, 305, 305, 306, 306, 307, 307, + 308, 309, 309, 310, 310, 310, 310, 311, 311, 311, + 311, 312, 312, 312, 312, 313, 313, 313, 314, 314, + 314, 315, 315, 315, 315, 315, 316, 316, 316, 317, + 317, 318, 318, 319, 319, 320, 320, 321, 321, 322, + 322, 323, 324, 323, 325, 325, 326, 326, 326, 326, + 326, 326, 326, 326, 326, 326, 326, 327, 327, 328, + 329, 329, 329, 329, 329, 329, 329, 329, 329, 331, + 330, 332, 332, 333, 334, 334, 335, 335, 336, 337, + 337, 338, 338, 338, 338, 339, 340, 340, 340, 340, + 340, 341, 341, 341, 341, 341, 342, 342, 343, 344, + 344, 344, 344, 345, 346, 346, 347, 347, 347, 348, + 349, 349, 350, 350, 350, 350, 350, 350, 351, 351, + 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, + 351, 351, 351, 351, 351, 351, 351, 352, 352, 353, + 353, 354, 354, 354, 354, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 356, 356, 356, 358, 357, 359, 357, 360, 360, 361, + 361, 362, 362, 363, 363, 364, 364, 364, 365, 365, + 366, 367, 367, 368, 368, 368, 368, 368, 368, 368, + 369, 370, 371, 369, 372, 372, 374, 373, 375, 373, + 376, 376, 377, 377, 378, 378, 379, 380, 380, 381, + 381, 383, 382, 384, 384, 385, 385, 387, 386, 388, + 386, 389, 386, 390, 390, 391, 391, 392, 392, 393, + 393, 393, 393, 393, 394, 394, 395, 395, 397, 396 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ static const yytype_uint8 yyr2[] = { 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 3, 1, 4, 1, 3, 2, 2, 1, - 1, 1, 2, 2, 2, 1, 2, 3, 2, 1, - 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, - 3, 3, 3, 1, 3, 3, 1, 3, 3, 1, - 3, 3, 3, 3, 1, 3, 3, 1, 3, 1, + 1, 1, 1, 1, 3, 1, 4, 1, 3, 2, + 2, 1, 1, 1, 2, 2, 2, 1, 2, 3, + 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, + 1, 1, 3, 3, 3, 1, 3, 3, 1, 3, + 3, 1, 3, 3, 3, 3, 1, 3, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, - 0, 6, 1, 3, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 3, 1, 2, 2, - 4, 2, 3, 4, 2, 3, 4, 0, 6, 2, - 3, 2, 1, 1, 2, 3, 3, 2, 3, 2, - 1, 2, 1, 1, 1, 3, 4, 6, 5, 1, - 2, 3, 5, 4, 1, 2, 1, 1, 1, 1, - 1, 4, 1, 3, 1, 3, 1, 1, 1, 2, + 3, 1, 0, 6, 1, 3, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, + 2, 2, 4, 2, 3, 4, 2, 3, 4, 0, + 6, 2, 3, 2, 1, 1, 2, 3, 3, 2, + 3, 2, 1, 2, 1, 1, 1, 3, 4, 6, + 5, 1, 2, 3, 5, 4, 1, 2, 1, 1, + 1, 1, 1, 4, 1, 3, 1, 3, 1, 1, + 1, 2, 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, 3, 1, + 2, 2, 3, 3, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 4, 1, 3, 1, 2, 2, - 3, 3, 4, 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, @@ -3287,216 +3352,238 @@ yyreduce: switch (yyn) { case 2: -#line 252 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 253 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string); } -#line 3295 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3360 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 3: -#line 258 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 259 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3303 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3368 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 4: -#line 261 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 262 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 3311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 5: -#line 264 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 265 "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 3320 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3385 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 6: -#line 268 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 269 "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 3329 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3394 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 7: -#line 272 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 273 "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 3338 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3403 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 8: -#line 276 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 277 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); +#ifdef AMD_EXTENSIONS + parseContext.int16Check((yyvsp[0].lex).loc, "16-bit integer literal"); + (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); +#endif } -#line 3346 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3414 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 9: -#line 279 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 283 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { +#ifdef AMD_EXTENSIONS + parseContext.int16Check((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); +#endif + } +#line 3425 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 10: +#line 289 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); + } +#line 3433 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 11: +#line 292 "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 3355 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3442 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 10: -#line 283 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 12: +#line 296 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS 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); #endif } -#line 3366 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3453 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 11: -#line 289 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 13: +#line 302 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 3374 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3461 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 12: -#line 292 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 14: +#line 305 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); if ((yyval.interm.intermTypedNode)->getAsConstantUnion()) (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } -#line 3384 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 13: -#line 300 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); - } -#line 3392 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 14: -#line 303 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode)); - } -#line 3400 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 15: -#line 306 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 313 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 16: -#line 309 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 316 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string); + (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode)); } -#line 3416 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3487 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 17: -#line 312 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 319 "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)); + (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3495 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 18: -#line 317 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 322 "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)); + (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string); } -#line 3436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3503 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 19: #line 325 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]"); - (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); + 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 3445 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3513 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 20: -#line 332 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 330 "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; + 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 3454 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3523 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 21: -#line 339 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 338 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - (yyval.interm) = (yyvsp[0].interm); + parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]"); + (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3462 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 22: #line 345 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - (yyval.interm) = (yyvsp[-1].interm); - (yyval.interm).loc = (yyvsp[0].lex).loc; + (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode); + delete (yyvsp[0].interm).function; } -#line 3471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3541 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 23: -#line 349 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 352 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm) = (yyvsp[0].interm); + } +#line 3549 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 24: +#line 358 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-1].interm); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 3480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 24: -#line 356 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm) = (yyvsp[-1].interm); - } -#line 3488 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3558 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 25: -#line 359 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 362 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - (yyval.interm) = (yyvsp[0].interm); + (yyval.interm) = (yyvsp[-1].interm); + (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 3496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 26: -#line 365 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 369 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm) = (yyvsp[-1].interm); + } +#line 3575 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 27: +#line 372 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm) = (yyvsp[0].interm); + } +#line 3583 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 28: +#line 378 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { TParameter param = { 0, new TType }; param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType()); @@ -3504,11 +3591,11 @@ yyreduce: (yyval.interm).function = (yyvsp[-1].interm).function; (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode); } -#line 3508 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3595 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 27: -#line 372 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 29: +#line 385 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { TParameter param = { 0, new TType }; param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType()); @@ -3516,29 +3603,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 3520 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3607 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 28: -#line 382 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 30: +#line 395 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-1].interm); } -#line 3528 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3615 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 29: -#line 390 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 31: +#line 403 "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 3538 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3625 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 30: -#line 395 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 32: +#line 408 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // // Should be a method or subroutine call, but we haven't recognized the arguments yet. @@ -3566,40 +3653,40 @@ yyreduce: (yyval.interm).function = new TFunction(&empty, TType(EbtVoid), EOpNull); } } -#line 3570 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3657 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 31: -#line 425 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 33: +#line 438 "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 3581 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 32: -#line 431 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 34: +#line 444 "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 3590 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3677 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 33: -#line 435 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 35: +#line 448 "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 3599 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3686 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 34: -#line 439 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 36: +#line 452 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-1].interm).op != EOpNull) { char errorOp[2] = {0, 0}; @@ -3616,179 +3703,179 @@ yyreduce: (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } } -#line 3620 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 35: -#line 459 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; } -#line 3626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 36: -#line 460 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; } -#line 3632 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3707 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 37: -#line 461 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; } -#line 3638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 472 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; } +#line 3713 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 38: -#line 462 "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 3645 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 473 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; } +#line 3719 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 39: -#line 468 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3651 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 474 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; } +#line 3725 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 40: -#line 469 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 475 "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 3732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 41: +#line 481 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } +#line 3738 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 42: +#line 482 "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 3661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3748 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 41: -#line 474 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 43: +#line 487 "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 3671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3758 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 42: -#line 479 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 44: +#line 492 "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 3682 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3769 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 43: -#line 488 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 45: +#line 501 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3688 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3775 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 44: -#line 489 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 46: +#line 502 "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 3698 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3785 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 45: -#line 494 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 47: +#line 507 "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 3708 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 46: -#line 502 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 48: +#line 515 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3714 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3801 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 47: -#line 503 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 49: +#line 516 "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 3725 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3812 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 48: -#line 509 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 50: +#line 522 "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 3736 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 49: -#line 518 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 51: +#line 531 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3829 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 50: -#line 519 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 52: +#line 532 "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 3752 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3839 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 51: -#line 524 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 53: +#line 537 "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 3762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3849 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 52: -#line 529 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 54: +#line 542 "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 3772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3859 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 53: -#line 534 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 55: +#line 547 "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 3782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3869 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 54: -#line 542 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 56: +#line 555 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3788 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3875 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 55: -#line 543 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 57: +#line 556 "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(), "=="); @@ -3797,11 +3884,11 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 3801 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3888 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 56: -#line 551 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 58: +#line 564 "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(), "!="); @@ -3810,124 +3897,124 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 3814 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3901 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 57: -#line 562 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 59: +#line 575 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3907 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 58: -#line 563 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 60: +#line 576 "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 3831 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3918 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 59: -#line 572 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 61: +#line 585 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3837 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3924 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 60: -#line 573 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 62: +#line 586 "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 3848 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3935 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 61: -#line 582 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 63: +#line 595 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3854 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3941 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 62: -#line 583 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 64: +#line 596 "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 3865 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3952 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 63: -#line 592 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 65: +#line 605 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3871 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 64: -#line 593 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 66: +#line 606 "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 3881 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 65: -#line 601 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 67: +#line 614 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3887 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3974 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 66: -#line 602 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 68: +#line 615 "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 3897 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3984 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 67: -#line 610 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 69: +#line 623 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3903 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3990 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 68: -#line 611 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 70: +#line 624 "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 3913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 69: -#line 619 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3919 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 70: -#line 620 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - ++parseContext.controlFlowNestingLevel; - } -#line 3927 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4000 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 71: -#line 623 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 632 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } +#line 4006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 72: +#line 633 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + ++parseContext.controlFlowNestingLevel; + } +#line 4014 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 73: +#line 636 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { --parseContext.controlFlowNestingLevel; parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode)); @@ -3940,17 +4027,17 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 3944 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4031 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 72: -#line 638 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 74: +#line 651 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 3950 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4037 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 73: -#line 639 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 75: +#line 652 "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(), "="); @@ -3963,119 +4050,119 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } } -#line 3967 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4054 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 74: -#line 654 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 76: +#line 667 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAssign; } -#line 3976 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4063 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 75: -#line 658 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 77: +#line 671 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpMulAssign; } -#line 3985 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4072 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 76: -#line 662 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 78: +#line 675 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpDivAssign; } -#line 3994 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4081 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 77: -#line 666 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 79: +#line 679 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%="); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpModAssign; } -#line 4004 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4091 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 78: -#line 671 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 80: +#line 684 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAddAssign; } -#line 4013 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4100 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 79: -#line 675 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 81: +#line 688 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpSubAssign; } -#line 4022 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4109 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 80: -#line 679 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 82: +#line 692 "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 4031 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4118 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 81: -#line 683 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 83: +#line 696 "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 4040 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4127 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 82: -#line 687 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 84: +#line 700 "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 4049 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 83: -#line 691 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 85: +#line 704 "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 4058 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4145 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 84: -#line 695 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 86: +#line 708 "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 4067 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4154 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 85: -#line 702 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 87: +#line 715 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4075 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4162 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 86: -#line 705 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 88: +#line 718 "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); @@ -4084,40 +4171,40 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 4088 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 87: -#line 716 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 89: +#line 729 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), ""); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4097 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4184 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 88: -#line 723 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 90: +#line 736 "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 4107 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4194 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 89: -#line 728 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 91: +#line 741 "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 4117 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4204 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 90: -#line 733 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 92: +#line 746 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement"); @@ -4126,75 +4213,75 @@ yyreduce: parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision); (yyval.interm.intermNode) = 0; } -#line 4130 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4217 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 91: -#line 741 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 93: +#line 754 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList); (yyval.interm.intermNode) = 0; } -#line 4139 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 92: -#line 745 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 94: +#line 758 "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 4148 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4235 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 93: -#line 749 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 95: +#line 762 "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 4157 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4244 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 94: -#line 753 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 96: +#line 766 "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 4167 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4254 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 95: -#line 758 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 97: +#line 771 "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 4177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 96: -#line 763 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 98: +#line 776 "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 4188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4275 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 97: -#line 772 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 99: +#line 785 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); } -#line 4194 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4281 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 98: -#line 772 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 100: +#line 785 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { --parseContext.structNestingLevel; parseContext.blockName = (yyvsp[-4].lex).string; @@ -4204,54 +4291,54 @@ yyreduce: (yyval.interm).loc = (yyvsp[-5].interm.type).loc; (yyval.interm).typeList = (yyvsp[-1].interm.typeList); } -#line 4208 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4295 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 99: -#line 783 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 101: +#line 796 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.identifierList) = new TIdentifierList; (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 4217 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4304 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 100: -#line 787 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 102: +#line 800 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList); (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 4226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4313 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 101: -#line 794 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 103: +#line 807 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).function = (yyvsp[-1].interm.function); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 4235 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 102: -#line 801 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.function) = (yyvsp[0].interm.function); - } -#line 4243 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 103: -#line 804 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.function) = (yyvsp[0].interm.function); - } -#line 4251 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4322 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 104: -#line 811 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 814 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.function) = (yyvsp[0].interm.function); + } +#line 4330 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 105: +#line 817 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.function) = (yyvsp[0].interm.function); + } +#line 4338 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 106: +#line 824 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // Add the parameter (yyval.interm.function) = (yyvsp[-1].interm.function); @@ -4260,11 +4347,11 @@ yyreduce: else delete (yyvsp[0].interm).param.type; } -#line 4264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 105: -#line 819 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 107: +#line 832 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // // Only first parameter of one-parameter functions can be void @@ -4282,11 +4369,11 @@ yyreduce: (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param); } } -#line 4286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4373 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 106: -#line 839 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 108: +#line 852 "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", @@ -4301,11 +4388,11 @@ yyreduce: function = new TFunction((yyvsp[-1].lex).string, type); (yyval.interm.function) = function; } -#line 4305 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4392 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 107: -#line 857 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 109: +#line 870 "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"); @@ -4321,11 +4408,11 @@ yyreduce: (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).param = param; } -#line 4325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4412 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 108: -#line 872 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 110: +#line 885 "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"); @@ -4343,11 +4430,11 @@ yyreduce: (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).param = param; } -#line 4347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4434 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 109: -#line 895 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 111: +#line 908 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) @@ -4359,11 +4446,11 @@ yyreduce: parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); } -#line 4363 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4450 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 110: -#line 906 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 112: +#line 919 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); @@ -4371,11 +4458,11 @@ yyreduce: parseContext.paramCheckFix((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 4375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4462 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 111: -#line 916 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 113: +#line 929 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) @@ -4386,11 +4473,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 4390 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4477 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 112: -#line 926 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 114: +#line 939 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); @@ -4398,118 +4485,118 @@ yyreduce: parseContext.paramCheckFix((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 4402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 113: -#line 936 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 115: +#line 949 "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 4413 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4500 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 114: -#line 945 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 116: +#line 958 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); } -#line 4421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4508 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 115: -#line 948 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 117: +#line 961 "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 4430 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4517 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 116: -#line 952 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 118: +#line 965 "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 4439 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 117: -#line 956 "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 4449 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 118: -#line 961 "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 4459 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 119: #line 969 "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); + (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 4469 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4536 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 120: #line 974 "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 4546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 121: +#line 982 "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 4556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 122: +#line 987 "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 4479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 121: -#line 979 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 123: +#line 992 "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 4489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 122: -#line 984 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 124: +#line 997 "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 4499 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4586 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 123: -#line 989 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 125: +#line 1002 "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 4509 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 124: -#line 998 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 126: +#line 1011 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); @@ -4521,11 +4608,11 @@ yyreduce: parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier); } -#line 4525 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4612 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 125: -#line 1009 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 127: +#line 1022 "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)); @@ -4550,22 +4637,22 @@ yyreduce: (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn))) (yyval.interm.type).qualifier.smooth = true; } -#line 4554 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4641 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 126: -#line 1036 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 128: +#line 1049 "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 4565 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4652 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 127: -#line 1045 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 129: +#line 1058 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "smooth"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth"); @@ -4573,11 +4660,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.smooth = true; } -#line 4577 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4664 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 128: -#line 1052 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 130: +#line 1065 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "flat"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat"); @@ -4585,11 +4672,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.flat = true; } -#line 4589 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4676 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 129: -#line 1059 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 131: +#line 1072 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective"); parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "noperspective"); @@ -4597,11 +4684,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nopersp = true; } -#line 4601 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4688 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 130: -#line 1066 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 132: +#line 1079 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD"); @@ -4611,84 +4698,84 @@ yyreduce: (yyval.interm.type).qualifier.explicitInterp = true; #endif } -#line 4615 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 131: -#line 1078 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type) = (yyvsp[-1].interm.type); - } -#line 4623 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 132: -#line 1084 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type) = (yyvsp[0].interm.type); - } -#line 4631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4702 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 133: -#line 1087 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1091 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type) = (yyvsp[-1].interm.type); + } +#line 4710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 134: +#line 1097 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type) = (yyvsp[0].interm.type); + } +#line 4718 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 135: +#line 1100 "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 4641 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4728 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 134: -#line 1094 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 136: +#line 1107 "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 4650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 135: -#line 1098 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 137: +#line 1111 "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 4659 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4746 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 136: -#line 1102 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 138: +#line 1115 "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 4669 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4756 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 137: -#line 1110 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 139: +#line 1123 "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 4680 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4767 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 138: -#line 1119 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 140: +#line 1132 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 4688 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4775 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 139: -#line 1122 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 141: +#line 1135 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[-1].interm.type); if ((yyval.interm.type).basicType == EbtVoid) @@ -4697,72 +4784,72 @@ 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 4701 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 140: -#line 1133 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type) = (yyvsp[0].interm.type); - } -#line 4709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 141: -#line 1136 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type) = (yyvsp[0].interm.type); - } -#line 4717 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4788 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 142: -#line 1139 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1146 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type) = (yyvsp[0].interm.type); + } +#line 4796 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 143: +#line 1149 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type) = (yyvsp[0].interm.type); + } +#line 4804 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 144: +#line 1152 "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 4726 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 143: -#line 1143 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - // allow inheritance of storage qualifier from block declaration - (yyval.interm.type) = (yyvsp[0].interm.type); - } -#line 4735 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 144: -#line 1147 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - // allow inheritance of storage qualifier from block declaration - (yyval.interm.type) = (yyvsp[0].interm.type); - } -#line 4744 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4813 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 145: -#line 1151 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1156 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 4753 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4822 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 146: -#line 1158 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1160 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + // allow inheritance of storage qualifier from block declaration + (yyval.interm.type) = (yyvsp[0].interm.type); + } +#line 4831 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 147: +#line 1164 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + // allow inheritance of storage qualifier from block declaration + (yyval.interm.type) = (yyvsp[0].interm.type); + } +#line 4840 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 148: +#line 1171 "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 4762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4849 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 147: -#line 1162 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 149: +#line 1175 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute"); @@ -4775,11 +4862,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 4779 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4866 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 148: -#line 1174 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 150: +#line 1187 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying"); @@ -4794,43 +4881,43 @@ yyreduce: else (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 4798 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 149: -#line 1188 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 151: +#line 1201 "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 4808 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4895 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 150: -#line 1193 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 152: +#line 1206 "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 4819 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4906 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 151: -#line 1199 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 153: +#line 1212 "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 4830 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4917 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 152: -#line 1205 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 154: +#line 1218 "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"); @@ -4838,52 +4925,52 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.centroid = true; } -#line 4842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4929 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 153: -#line 1212 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 155: +#line 1225 "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 4853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 154: -#line 1218 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 156: +#line 1231 "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 4863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4950 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 155: -#line 1223 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 157: +#line 1236 "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 4873 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4960 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 156: -#line 1228 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 158: +#line 1241 "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 4883 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4970 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 157: -#line 1233 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 159: +#line 1246 "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"); @@ -4892,126 +4979,126 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqShared; } -#line 4896 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4983 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 158: -#line 1241 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 160: +#line 1254 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.coherent = true; } -#line 4905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4992 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 159: -#line 1245 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 161: +#line 1258 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.volatil = true; } -#line 4914 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 160: -#line 1249 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 162: +#line 1262 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.restrict = true; } -#line 4923 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5010 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 161: -#line 1253 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 163: +#line 1266 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.readonly = true; } -#line 4932 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5019 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 162: -#line 1257 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 164: +#line 1270 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.writeonly = true; } -#line 4941 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5028 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 163: -#line 1261 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 165: +#line 1274 "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 4952 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 164: -#line 1267 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 166: +#line 1280 "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 4963 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5050 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 165: -#line 1276 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 167: +#line 1289 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // TODO } -#line 4971 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5058 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 166: -#line 1279 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 168: +#line 1292 "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 4981 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5068 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 167: -#line 1287 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 169: +#line 1300 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); } -#line 4990 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5077 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 168: -#line 1291 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 170: +#line 1304 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.arrayDimCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes, 0); (yyval.interm.type) = (yyvsp[-1].interm.type); (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes; } -#line 5001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5088 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 169: -#line 1300 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 171: +#line 1313 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).arraySizes = new TArraySizes; (yyval.interm).arraySizes->addInnerSize(); } -#line 5011 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5098 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 170: -#line 1305 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 172: +#line 1318 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[-2].lex).loc; (yyval.interm).arraySizes = new TArraySizes; @@ -5020,20 +5107,20 @@ yyreduce: parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size); (yyval.interm).arraySizes->addInnerSize(size); } -#line 5024 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 171: -#line 1313 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 173: +#line 1326 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-2].interm); (yyval.interm).arraySizes->addInnerSize(); } -#line 5033 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5120 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 172: -#line 1317 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 174: +#line 1330 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-3].interm); @@ -5041,39 +5128,39 @@ yyreduce: parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size); (yyval.interm).arraySizes->addInnerSize(size); } -#line 5045 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5132 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 173: -#line 1327 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 175: +#line 1340 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtVoid; } -#line 5054 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 174: -#line 1331 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 176: +#line 1344 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } -#line 5063 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5150 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 175: -#line 1335 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 177: +#line 1348 "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 5073 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 176: -#line 1340 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 178: +#line 1353 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16Check((yyvsp[0].lex).loc, "half float", parseContext.symbolTable.atBuiltInLevel()); @@ -5081,572 +5168,674 @@ yyreduce: (yyval.interm.type).basicType = EbtFloat16; #endif } -#line 5085 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5172 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 177: -#line 1347 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 179: +#line 1360 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } -#line 5094 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5181 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 178: -#line 1351 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 180: +#line 1364 "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 5104 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5191 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 179: -#line 1356 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 181: +#line 1369 "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 5114 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5201 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 180: -#line 1361 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 182: +#line 1374 "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 5124 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 181: -#line 1366 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtBool; - } -#line 5133 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 182: -#line 1370 "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 5143 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5211 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 183: -#line 1375 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1379 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { +#ifdef AMD_EXTENSIONS + parseContext.int16Check((yyvsp[0].lex).loc, "16-bit integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setVector(3); + (yyval.interm.type).basicType = EbtInt16; +#endif } -#line 5153 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5223 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 184: -#line 1380 "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 5163 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 185: -#line 1385 "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 5174 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 186: -#line 1391 "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 5185 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 187: -#line 1397 "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 5196 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 188: -#line 1403 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1386 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS - parseContext.float16Check((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); + parseContext.int16Check((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 = EbtFloat16; - (yyval.interm.type).setVector(2); -#endif - } -#line 5209 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 189: -#line 1411 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { -#ifdef AMD_EXTENSIONS - parseContext.float16Check((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); -#endif - } -#line 5222 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 190: -#line 1419 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { -#ifdef AMD_EXTENSIONS - parseContext.float16Check((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); + (yyval.interm.type).basicType = EbtUint16; #endif } #line 5235 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 191: -#line 1427 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 185: +#line 1393 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; + } +#line 5244 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 186: +#line 1397 "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 5245 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5254 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 192: -#line 1432 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 187: +#line 1402 "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(3); } -#line 5255 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 193: -#line 1437 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 188: +#line 1407 "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 5265 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5274 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 194: -#line 1442 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 189: +#line 1412 "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 = EbtInt; + (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(2); } -#line 5275 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 195: -#line 1447 "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 5285 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; + case 190: +#line 1418 "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 5296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 191: +#line 1424 "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 5307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 192: +#line 1430 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { +#ifdef AMD_EXTENSIONS + parseContext.float16Check((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); +#endif + } +#line 5320 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 193: +#line 1438 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { +#ifdef AMD_EXTENSIONS + parseContext.float16Check((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); +#endif + } +#line 5333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 194: +#line 1446 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { +#ifdef AMD_EXTENSIONS + parseContext.float16Check((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); +#endif + } +#line 5346 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 195: +#line 1454 "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).setVector(2); + } +#line 5356 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + case 196: -#line 1452 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1459 "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).setVector(3); + } +#line 5366 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 197: +#line 1464 "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).setVector(4); + } +#line 5376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 198: +#line 1469 "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(2); + } +#line 5386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 199: +#line 1474 "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 5396 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 200: +#line 1479 "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); } -#line 5295 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 197: -#line 1457 "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 5306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 198: -#line 1463 "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 5317 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 199: -#line 1469 "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 5328 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 200: -#line 1475 "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 5339 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 201: -#line 1481 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1484 "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 5417 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 202: +#line 1490 "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 5428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 203: +#line 1496 "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 5439 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 204: +#line 1502 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { +#ifdef AMD_EXTENSIONS + parseContext.int16Check((yyvsp[0].lex).loc, "16-bit 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); +#endif + } +#line 5452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 205: +#line 1510 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { +#ifdef AMD_EXTENSIONS + parseContext.int16Check((yyvsp[0].lex).loc, "16-bit 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); +#endif + } +#line 5465 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 206: +#line 1518 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { +#ifdef AMD_EXTENSIONS + parseContext.int16Check((yyvsp[0].lex).loc, "16-bit 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); +#endif + } +#line 5478 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 207: +#line 1526 "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 5489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 208: +#line 1532 "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 5350 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5500 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 202: -#line 1487 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 209: +#line 1538 "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 5361 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5511 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 203: -#line 1493 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 210: +#line 1544 "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 5372 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5522 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 204: -#line 1499 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 211: +#line 1550 "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 5383 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5533 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 205: -#line 1505 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 212: +#line 1556 "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 5394 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 206: -#line 1511 "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 5404 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 207: -#line 1516 "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 5414 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 208: -#line 1521 "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 5424 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 209: -#line 1526 "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 5434 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 210: -#line 1531 "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 5444 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 211: -#line 1536 "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 5454 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 212: -#line 1541 "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 5464 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5544 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 213: -#line 1546 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1562 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { +#ifdef AMD_EXTENSIONS + parseContext.int16Check((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 = EbtFloat; - (yyval.interm.type).setMatrix(3, 3); + (yyval.interm.type).basicType = EbtUint16; + (yyval.interm.type).setVector(2); +#endif } -#line 5474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5557 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 214: -#line 1551 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1570 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { +#ifdef AMD_EXTENSIONS + parseContext.int16Check((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 = EbtFloat; - (yyval.interm.type).setMatrix(3, 4); + (yyval.interm.type).basicType = EbtUint16; + (yyval.interm.type).setVector(3); +#endif } -#line 5484 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5570 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 215: -#line 1556 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1578 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { +#ifdef AMD_EXTENSIONS + parseContext.int16Check((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 = EbtFloat; - (yyval.interm.type).setMatrix(4, 2); + (yyval.interm.type).basicType = EbtUint16; + (yyval.interm.type).setVector(4); +#endif } -#line 5494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5583 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 216: -#line 1561 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1586 "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(2, 2); } -#line 5504 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5593 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 217: -#line 1566 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1591 "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 5603 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 218: +#line 1596 "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 5514 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 218: -#line 1571 "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); - } -#line 5525 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 219: -#line 1577 "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 5536 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 220: -#line 1583 "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 5547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 221: -#line 1589 "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); - } -#line 5558 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 222: -#line 1595 "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); - } -#line 5569 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 223: -#line 1601 "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); - } -#line 5580 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 224: -#line 1607 "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 5591 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 225: -#line 1613 "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 5602 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 226: -#line 1619 "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 5613 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 227: -#line 1625 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 219: +#line 1601 "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).basicType = EbtFloat; + (yyval.interm.type).setMatrix(2, 2); + } +#line 5623 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 220: +#line 1606 "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 5633 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 221: +#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).setMatrix(2, 4); + } +#line 5643 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 222: +#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).setMatrix(3, 2); + } +#line 5653 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 223: +#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).setMatrix(3, 3); + } +#line 5663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 224: +#line 1626 "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); + } +#line 5673 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 225: +#line 1631 "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); } -#line 5624 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 226: +#line 1636 "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 5693 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 227: +#line 1641 "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 5703 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 228: -#line 1631 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1646 "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, 2); } -#line 5635 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5714 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 229: -#line 1637 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1652 "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 5725 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 230: +#line 1658 "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 5646 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5736 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 230: -#line 1643 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 231: +#line 1664 "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); + } +#line 5747 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 232: +#line 1670 "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); + } +#line 5758 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 233: +#line 1676 "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); + } +#line 5769 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 234: +#line 1682 "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 5780 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 235: +#line 1688 "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 5791 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 236: +#line 1694 "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 5802 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 237: +#line 1700 "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 5813 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 238: +#line 1706 "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 5824 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 239: +#line 1712 "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 5835 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 240: +#line 1718 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); @@ -5655,11 +5844,11 @@ yyreduce: (yyval.interm.type).setMatrix(2, 2); #endif } -#line 5659 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5848 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 231: -#line 1651 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 241: +#line 1726 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); @@ -5668,11 +5857,11 @@ yyreduce: (yyval.interm.type).setMatrix(3, 3); #endif } -#line 5672 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5861 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 232: -#line 1659 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 242: +#line 1734 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); @@ -5681,11 +5870,11 @@ yyreduce: (yyval.interm.type).setMatrix(4, 4); #endif } -#line 5685 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5874 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 233: -#line 1667 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 243: +#line 1742 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); @@ -5694,11 +5883,11 @@ yyreduce: (yyval.interm.type).setMatrix(2, 2); #endif } -#line 5698 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5887 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 234: -#line 1675 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 244: +#line 1750 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); @@ -5707,11 +5896,11 @@ yyreduce: (yyval.interm.type).setMatrix(2, 3); #endif } -#line 5711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 235: -#line 1683 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 245: +#line 1758 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); @@ -5720,11 +5909,11 @@ yyreduce: (yyval.interm.type).setMatrix(2, 4); #endif } -#line 5724 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 236: -#line 1691 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 246: +#line 1766 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); @@ -5733,11 +5922,11 @@ yyreduce: (yyval.interm.type).setMatrix(3, 2); #endif } -#line 5737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5926 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 237: -#line 1699 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 247: +#line 1774 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); @@ -5746,11 +5935,11 @@ yyreduce: (yyval.interm.type).setMatrix(3, 3); #endif } -#line 5750 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5939 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 238: -#line 1707 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 248: +#line 1782 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); @@ -5759,11 +5948,11 @@ yyreduce: (yyval.interm.type).setMatrix(3, 4); #endif } -#line 5763 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5952 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 239: -#line 1715 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 249: +#line 1790 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); @@ -5772,11 +5961,11 @@ yyreduce: (yyval.interm.type).setMatrix(4, 2); #endif } -#line 5776 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5965 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 240: -#line 1723 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 250: +#line 1798 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); @@ -5785,11 +5974,11 @@ yyreduce: (yyval.interm.type).setMatrix(4, 3); #endif } -#line 5789 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5978 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 241: -#line 1731 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 251: +#line 1806 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); @@ -5798,1188 +5987,1188 @@ yyreduce: (yyval.interm.type).setMatrix(4, 4); #endif } -#line 5802 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5991 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 242: -#line 1739 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 252: +#line 1814 "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 5812 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 243: -#line 1744 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 253: +#line 1819 "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 5822 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6011 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 244: -#line 1749 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 254: +#line 1824 "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 5832 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 245: -#line 1754 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 255: +#line 1829 "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 5842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6031 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 246: -#line 1759 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 256: +#line 1834 "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 5852 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6041 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 247: -#line 1764 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 257: +#line 1839 "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 5862 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6051 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 248: -#line 1769 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 258: +#line 1844 "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 5872 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6061 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 249: -#line 1774 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 259: +#line 1849 "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 5882 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6071 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 250: -#line 1779 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 260: +#line 1854 "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 5892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6081 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 251: -#line 1784 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 261: +#line 1859 "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 5902 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6091 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 252: -#line 1789 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 262: +#line 1864 "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 5912 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6101 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 253: -#line 1794 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 263: +#line 1869 "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 5922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 254: -#line 1799 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 264: +#line 1874 "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 5932 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6121 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 255: -#line 1804 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 265: +#line 1879 "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 5942 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 256: -#line 1809 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 266: +#line 1884 "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 5952 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 257: -#line 1814 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 267: +#line 1889 "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 5962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6151 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 258: -#line 1819 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 268: +#line 1894 "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 5972 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6161 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 259: -#line 1824 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 269: +#line 1899 "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 5982 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6171 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 260: -#line 1829 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 270: +#line 1904 "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 5992 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6181 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 261: -#line 1834 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 271: +#line 1909 "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 6002 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6191 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 262: -#line 1839 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 272: +#line 1914 "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 6012 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6201 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 263: -#line 1844 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 273: +#line 1919 "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 6022 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6211 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 264: -#line 1849 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 274: +#line 1924 "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 6032 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 265: -#line 1854 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 275: +#line 1929 "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 6042 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6231 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 266: -#line 1859 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 276: +#line 1934 "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 6052 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6241 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 267: -#line 1864 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 277: +#line 1939 "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 6062 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6251 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 268: -#line 1869 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 278: +#line 1944 "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 6072 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6261 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 269: -#line 1874 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 279: +#line 1949 "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 6082 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6271 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 270: -#line 1879 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 280: +#line 1954 "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 6092 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6281 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 271: -#line 1884 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 281: +#line 1959 "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 6102 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6291 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 272: -#line 1889 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 282: +#line 1964 "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 6112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6301 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 273: -#line 1894 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 283: +#line 1969 "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 6122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 274: -#line 1899 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 284: +#line 1974 "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 6132 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6321 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 275: -#line 1904 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 285: +#line 1979 "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 6142 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 276: -#line 1909 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 286: +#line 1984 "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 6152 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6341 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 277: -#line 1914 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 287: +#line 1989 "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 6162 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 278: -#line 1919 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 288: +#line 1994 "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 6172 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6361 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 279: -#line 1924 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 289: +#line 1999 "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 6182 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6371 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 280: -#line 1929 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 290: +#line 2004 "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 6192 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 281: -#line 1934 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 291: +#line 2009 "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 6202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 282: -#line 1939 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 292: +#line 2014 "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 6212 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6401 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 283: -#line 1944 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 293: +#line 2019 "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 6222 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6411 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 284: -#line 1949 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 294: +#line 2024 "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 6232 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 285: -#line 1954 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 295: +#line 2029 "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 6242 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6431 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 286: -#line 1959 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 296: +#line 2034 "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 6252 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 287: -#line 1964 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 297: +#line 2039 "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 6262 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6451 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 288: -#line 1969 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 298: +#line 2044 "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 6272 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6461 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 289: -#line 1974 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 299: +#line 2049 "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 6282 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 290: -#line 1979 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 300: +#line 2054 "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 6292 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6481 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 291: -#line 1984 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 301: +#line 2059 "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 6302 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6491 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 292: -#line 1989 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 302: +#line 2064 "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 6312 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6501 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 293: -#line 1994 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 303: +#line 2069 "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 6322 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6511 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 294: -#line 1999 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 304: +#line 2074 "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 6332 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6521 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 295: -#line 2004 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 305: +#line 2079 "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 6342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6531 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 296: -#line 2009 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 306: +#line 2084 "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 6352 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6541 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 297: -#line 2014 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 307: +#line 2089 "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 6362 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6551 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 298: -#line 2019 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 308: +#line 2094 "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 6372 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6561 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 299: -#line 2024 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 309: +#line 2099 "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 6382 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6571 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 300: -#line 2029 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 310: +#line 2104 "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 6392 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6581 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 301: -#line 2034 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 311: +#line 2109 "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 6402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6591 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 302: -#line 2039 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 312: +#line 2114 "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 6412 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6601 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 303: -#line 2044 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 313: +#line 2119 "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 6422 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6611 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 304: -#line 2049 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 314: +#line 2124 "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 6432 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6621 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 305: -#line 2054 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 315: +#line 2129 "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 6442 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 306: -#line 2059 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 316: +#line 2134 "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 6452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6641 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 307: -#line 2064 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 317: +#line 2139 "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 6462 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6651 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 308: -#line 2069 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 318: +#line 2144 "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 6472 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 309: -#line 2074 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 319: +#line 2149 "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 6482 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 310: -#line 2079 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 320: +#line 2154 "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 6492 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 311: -#line 2084 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 321: +#line 2159 "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 6502 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 312: -#line 2089 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 322: +#line 2164 "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 6512 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6701 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 313: -#line 2094 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 323: +#line 2169 "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 6522 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 314: -#line 2099 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 324: +#line 2174 "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 6532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6721 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 315: -#line 2104 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 325: +#line 2179 "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 6542 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6731 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 316: -#line 2109 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 326: +#line 2184 "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 6552 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 317: -#line 2114 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 327: +#line 2189 "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 6562 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 318: -#line 2119 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 328: +#line 2194 "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 6572 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6761 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 319: -#line 2124 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 329: +#line 2199 "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 6582 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 320: -#line 2129 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 330: +#line 2204 "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 6592 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6781 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 321: -#line 2134 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 331: +#line 2209 "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 6602 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6791 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 322: -#line 2139 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 332: +#line 2214 "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 6612 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6801 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 323: -#line 2144 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 333: +#line 2219 "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 6622 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6811 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 324: -#line 2149 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 334: +#line 2224 "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 6632 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6821 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 325: -#line 2154 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 335: +#line 2229 "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 6642 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6831 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 326: -#line 2159 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 336: +#line 2234 "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 6652 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6841 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 327: -#line 2164 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 337: +#line 2239 "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 6662 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6851 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 328: -#line 2169 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 338: +#line 2244 "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 6672 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6861 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 329: -#line 2174 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 339: +#line 2249 "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 6682 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6871 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 330: -#line 2179 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 340: +#line 2254 "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 6692 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6881 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 331: -#line 2184 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 341: +#line 2259 "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 6702 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6891 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 332: -#line 2189 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 342: +#line 2264 "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 6712 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6901 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 333: -#line 2194 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 343: +#line 2269 "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 6722 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6911 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 334: -#line 2199 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 344: +#line 2274 "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 6732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6921 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 335: -#line 2204 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 345: +#line 2279 "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 6742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6931 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 336: -#line 2209 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 346: +#line 2284 "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 6752 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6941 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 337: -#line 2214 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 347: +#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.setImage(EbtInt, Esd1D, true); } -#line 6762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6951 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 338: -#line 2219 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 348: +#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.setImage(EbtUint, Esd1D, true); } -#line 6772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6961 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 339: -#line 2224 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 349: +#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.setImage(EbtFloat, Esd2D, true); } -#line 6782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6971 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 340: -#line 2229 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 350: +#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.setImage(EbtInt, Esd2D, true); } -#line 6792 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6981 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 341: -#line 2234 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 351: +#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.setImage(EbtUint, Esd2D, true); } -#line 6802 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6991 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 342: -#line 2239 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 352: +#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.setImage(EbtFloat, EsdCube, true); } -#line 6812 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 343: -#line 2244 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 353: +#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.setImage(EbtInt, EsdCube, true); } -#line 6822 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7011 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 344: -#line 2249 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 354: +#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.setImage(EbtUint, EsdCube, true); } -#line 6832 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 345: -#line 2254 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 355: +#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.setImage(EbtFloat, Esd2D, false, false, true); } -#line 6842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7031 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 346: -#line 2259 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 356: +#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.setImage(EbtInt, Esd2D, false, false, true); } -#line 6852 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7041 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 347: -#line 2264 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 357: +#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.setImage(EbtUint, Esd2D, false, false, true); } -#line 6862 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7051 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 348: -#line 2269 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 358: +#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.setImage(EbtFloat, Esd2D, true, false, true); } -#line 6872 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7061 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 349: -#line 2274 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 359: +#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.setImage(EbtInt, Esd2D, true, false, true); } -#line 6882 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7071 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 350: -#line 2279 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 360: +#line 2354 "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 6892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7081 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 351: -#line 2284 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 361: +#line 2359 "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 6903 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7092 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 352: -#line 2290 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 362: +#line 2365 "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 6914 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7103 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 353: -#line 2296 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 363: +#line 2371 "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 6925 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7114 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 354: -#line 2302 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 364: +#line 2377 "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 6936 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7125 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 355: -#line 2308 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 365: +#line 2383 "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 6947 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 356: -#line 2314 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 366: +#line 2389 "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 6958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7147 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 357: -#line 2320 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 367: +#line 2395 "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 6969 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7158 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 358: -#line 2326 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 368: +#line 2401 "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 6979 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7168 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 359: -#line 2331 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 369: +#line 2406 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // // This is for user defined type names. The lexical phase looked up the @@ -6993,47 +7182,47 @@ yyreduce: } else parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), ""); } -#line 6997 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7186 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 360: -#line 2347 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 370: +#line 2422 "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 7007 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7196 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 361: -#line 2352 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 371: +#line 2427 "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 7017 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 362: -#line 2357 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 372: +#line 2432 "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 7027 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 363: -#line 2365 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 373: +#line 2440 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); } -#line 7033 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7222 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 364: -#line 2365 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 374: +#line 2440 "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); @@ -7045,17 +7234,17 @@ yyreduce: (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 7049 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7238 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 365: -#line 2376 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 375: +#line 2451 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); } -#line 7055 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7244 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 366: -#line 2376 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 376: +#line 2451 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { TType* structure = new TType((yyvsp[-1].interm.typeList), TString("")); (yyval.interm.type).init((yyvsp[-4].lex).loc); @@ -7063,19 +7252,19 @@ yyreduce: (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 7067 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7256 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 367: -#line 2386 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 377: +#line 2461 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList) = (yyvsp[0].interm.typeList); } -#line 7075 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 368: -#line 2389 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 378: +#line 2464 "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) { @@ -7086,11 +7275,11 @@ yyreduce: (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]); } } -#line 7090 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7279 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 369: -#line 2402 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 379: +#line 2477 "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"); @@ -7109,11 +7298,11 @@ yyreduce: (*(yyval.interm.typeList))[i].type->mergeType((yyvsp[-2].interm.type)); } } -#line 7113 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7302 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 370: -#line 2420 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 380: +#line 2495 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalQualifierFixCheck((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier); if ((yyvsp[-2].interm.type).arraySizes) { @@ -7135,38 +7324,38 @@ yyreduce: (*(yyval.interm.typeList))[i].type->mergeType((yyvsp[-2].interm.type)); } } -#line 7139 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7328 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 371: -#line 2444 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 381: +#line 2519 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList) = new TTypeList; (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 7148 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7337 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 372: -#line 2448 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 382: +#line 2523 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 7156 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7345 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 373: -#line 2454 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 383: +#line 2529 "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 7166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7355 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 374: -#line 2459 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 384: +#line 2534 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.arrayDimCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes, 0); @@ -7175,219 +7364,219 @@ yyreduce: (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string); (yyval.interm.typeLine).type->newArraySizes(*(yyvsp[0].interm).arraySizes); } -#line 7179 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7368 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 375: -#line 2470 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 385: +#line 2545 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 7187 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 376: -#line 2473 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 386: +#line 2548 "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 7198 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7387 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 377: -#line 2479 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 387: +#line 2554 "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 7209 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 378: -#line 2488 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc()); - } -#line 7217 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 379: -#line 2491 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); - } -#line 7225 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 380: -#line 2497 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7231 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 381: -#line 2501 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7237 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 382: -#line 2502 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7243 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 383: -#line 2508 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7249 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 384: -#line 2509 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7255 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 385: -#line 2510 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7261 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 386: -#line 2511 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7267 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 387: -#line 2512 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7273 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7398 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 388: -#line 2513 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7279 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 2563 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc()); + } +#line 7406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 389: -#line 2514 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7285 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 2566 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); + } +#line 7414 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 390: -#line 2518 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = 0; } -#line 7291 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 2572 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 7420 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 391: -#line 2519 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2576 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 7426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 392: +#line 2577 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 7432 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 393: +#line 2583 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 7438 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 394: +#line 2584 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 7444 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 395: +#line 2585 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 7450 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 396: +#line 2586 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 7456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 397: +#line 2587 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 7462 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 398: +#line 2588 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 7468 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 399: +#line 2589 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 7474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 400: +#line 2593 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = 0; } +#line 7480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 401: +#line 2594 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; } -#line 7300 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 392: -#line 2523 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 402: +#line 2598 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; } -#line 7309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7498 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 393: -#line 2527 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 403: +#line 2602 "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 7319 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7508 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 394: -#line 2535 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 404: +#line 2610 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7514 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 395: -#line 2536 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 405: +#line 2611 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7520 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 396: -#line 2540 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 406: +#line 2615 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { ++parseContext.controlFlowNestingLevel; } -#line 7339 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7528 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 397: -#line 2543 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 407: +#line 2618 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7348 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 398: -#line 2547 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 408: +#line 2622 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 7358 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 399: -#line 2552 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 409: +#line 2627 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7369 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7558 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 400: -#line 2561 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 410: +#line 2636 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; } -#line 7377 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 401: -#line 2564 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 411: +#line 2639 "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 7387 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 402: -#line 2572 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 412: +#line 2647 "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 || @@ -7396,11 +7585,11 @@ yyreduce: (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case } } -#line 7400 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7589 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 403: -#line 2580 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 413: +#line 2655 "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)) { @@ -7409,59 +7598,59 @@ yyreduce: } else (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 7413 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7602 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 404: -#line 2591 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 414: +#line 2666 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; } -#line 7419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7608 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 405: -#line 2592 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 415: +#line 2667 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = static_cast((yyvsp[-1].interm.intermTypedNode)); } -#line 7425 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7614 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 406: -#line 2596 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 416: +#line 2671 "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 7434 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7623 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 407: -#line 2603 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 417: +#line 2678 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode); } -#line 7443 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7632 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 408: -#line 2607 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 418: +#line 2682 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode); (yyval.interm.nodePair).node2 = 0; } -#line 7452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7641 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 409: -#line 2615 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 419: +#line 2690 "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 7461 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 410: -#line 2619 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 420: +#line 2694 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type)); @@ -7472,11 +7661,11 @@ yyreduce: else (yyval.interm.intermTypedNode) = 0; } -#line 7476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7665 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 411: -#line 2632 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 421: +#line 2707 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // start new switch sequence on the switch stack ++parseContext.controlFlowNestingLevel; @@ -7485,11 +7674,11 @@ yyreduce: parseContext.switchLevel.push_back(parseContext.statementNestingLevel); parseContext.symbolTable.push(); } -#line 7489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 412: -#line 2640 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 422: +#line 2715 "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(); @@ -7499,27 +7688,27 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 7503 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7692 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 413: -#line 2652 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 423: +#line 2727 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; } -#line 7511 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7700 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 414: -#line 2655 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 424: +#line 2730 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7519 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7708 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 415: -#line 2661 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 425: +#line 2736 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -7532,11 +7721,11 @@ yyreduce: (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc); } } -#line 7536 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7725 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 416: -#line 2673 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 426: +#line 2748 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -7546,11 +7735,11 @@ yyreduce: else (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc); } -#line 7550 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7739 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 417: -#line 2685 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 427: +#line 2760 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", ""); @@ -7559,11 +7748,11 @@ yyreduce: ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 7563 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7752 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 418: -#line 2693 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 428: +#line 2768 "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); @@ -7571,21 +7760,21 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 7575 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7764 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 419: -#line 2700 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 429: +#line 2775 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 7585 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7774 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 420: -#line 2705 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 430: +#line 2780 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", ""); @@ -7597,22 +7786,22 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 7601 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7790 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 421: -#line 2716 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 431: +#line 2791 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.push(); ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 7612 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7801 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 422: -#line 2722 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 432: +#line 2797 "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); @@ -7625,81 +7814,81 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 7629 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7818 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 423: -#line 2737 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 433: +#line 2812 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7637 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7826 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 424: -#line 2740 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 434: +#line 2815 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7645 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7834 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 425: -#line 2746 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 435: +#line 2821 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 7653 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 426: -#line 2749 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 436: +#line 2824 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = 0; } -#line 7661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7850 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 427: -#line 2755 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 437: +#line 2830 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode); (yyval.interm.nodePair).node2 = 0; } -#line 7670 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7859 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 428: -#line 2759 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 438: +#line 2834 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode); } -#line 7679 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7868 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 429: -#line 2766 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 439: +#line 2841 "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 7689 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7878 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 430: -#line 2771 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 440: +#line 2846 "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 7699 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7888 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 431: -#line 2776 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 441: +#line 2851 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc); if (parseContext.currentFunctionType->getBasicType() != EbtVoid) @@ -7707,71 +7896,71 @@ yyreduce: if (parseContext.inMain) parseContext.postEntryPointReturn = true; } -#line 7711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 432: -#line 2783 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 442: +#line 2858 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode)); } -#line 7719 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7908 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 433: -#line 2786 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 443: +#line 2861 "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 7728 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7917 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 434: -#line 2795 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 444: +#line 2870 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } -#line 7737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7926 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 435: -#line 2799 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 445: +#line 2874 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } -#line 7746 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7935 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 436: -#line 2806 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 446: +#line 2881 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7754 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7943 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 437: -#line 2809 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 447: +#line 2884 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 7762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7951 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 438: -#line 2815 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 448: +#line 2890 "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 7771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7960 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 439: -#line 2819 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 449: +#line 2894 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // May be best done as post process phase on intermediate code if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue) @@ -7787,11 +7976,11 @@ yyreduce: (yyval.interm.intermNode)->getAsAggregate()->setDebug(parseContext.contextPragma.debug); (yyval.interm.intermNode)->getAsAggregate()->addToPragmaTable(parseContext.contextPragma.pragmaTable); } -#line 7791 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7980 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; -#line 7795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7984 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -8019,5 +8208,5 @@ yyreturn: #endif return yyresult; } -#line 2836 "MachineIndependent/glslang.y" /* yacc.c:1906 */ +#line 2911 "MachineIndependent/glslang.y" /* yacc.c:1906 */ diff --git a/glslang/MachineIndependent/glslang_tab.cpp.h b/glslang/MachineIndependent/glslang_tab.cpp.h index bf59a037..b8e78d6c 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp.h +++ b/glslang/MachineIndependent/glslang_tab.cpp.h @@ -55,281 +55,291 @@ extern int yydebug; UINT = 265, INT64_T = 266, UINT64_T = 267, - FLOAT16_T = 268, - BREAK = 269, - CONTINUE = 270, - DO = 271, - ELSE = 272, - FOR = 273, - IF = 274, - DISCARD = 275, - RETURN = 276, - SWITCH = 277, - CASE = 278, - DEFAULT = 279, - SUBROUTINE = 280, - BVEC2 = 281, - BVEC3 = 282, - BVEC4 = 283, - IVEC2 = 284, - IVEC3 = 285, - IVEC4 = 286, - I64VEC2 = 287, - I64VEC3 = 288, - I64VEC4 = 289, - UVEC2 = 290, - UVEC3 = 291, - UVEC4 = 292, - U64VEC2 = 293, - U64VEC3 = 294, - U64VEC4 = 295, - VEC2 = 296, - VEC3 = 297, - VEC4 = 298, - MAT2 = 299, - MAT3 = 300, - MAT4 = 301, - CENTROID = 302, - IN = 303, - OUT = 304, - INOUT = 305, - UNIFORM = 306, - PATCH = 307, - SAMPLE = 308, - BUFFER = 309, - SHARED = 310, - COHERENT = 311, - VOLATILE = 312, - RESTRICT = 313, - READONLY = 314, - WRITEONLY = 315, - DVEC2 = 316, - DVEC3 = 317, - DVEC4 = 318, - DMAT2 = 319, - DMAT3 = 320, - DMAT4 = 321, - F16VEC2 = 322, - F16VEC3 = 323, - F16VEC4 = 324, - F16MAT2 = 325, - F16MAT3 = 326, - F16MAT4 = 327, - NOPERSPECTIVE = 328, - FLAT = 329, - SMOOTH = 330, - LAYOUT = 331, - __EXPLICITINTERPAMD = 332, - MAT2X2 = 333, - MAT2X3 = 334, - MAT2X4 = 335, - MAT3X2 = 336, - MAT3X3 = 337, - MAT3X4 = 338, - MAT4X2 = 339, - MAT4X3 = 340, - MAT4X4 = 341, - DMAT2X2 = 342, - DMAT2X3 = 343, - DMAT2X4 = 344, - DMAT3X2 = 345, - DMAT3X3 = 346, - DMAT3X4 = 347, - DMAT4X2 = 348, - DMAT4X3 = 349, - DMAT4X4 = 350, - F16MAT2X2 = 351, - F16MAT2X3 = 352, - F16MAT2X4 = 353, - F16MAT3X2 = 354, - F16MAT3X3 = 355, - F16MAT3X4 = 356, - F16MAT4X2 = 357, - F16MAT4X3 = 358, - F16MAT4X4 = 359, - ATOMIC_UINT = 360, - SAMPLER1D = 361, - SAMPLER2D = 362, - SAMPLER3D = 363, - SAMPLERCUBE = 364, - SAMPLER1DSHADOW = 365, - SAMPLER2DSHADOW = 366, - SAMPLERCUBESHADOW = 367, - SAMPLER1DARRAY = 368, - SAMPLER2DARRAY = 369, - SAMPLER1DARRAYSHADOW = 370, - SAMPLER2DARRAYSHADOW = 371, - ISAMPLER1D = 372, - ISAMPLER2D = 373, - ISAMPLER3D = 374, - ISAMPLERCUBE = 375, - ISAMPLER1DARRAY = 376, - ISAMPLER2DARRAY = 377, - USAMPLER1D = 378, - USAMPLER2D = 379, - USAMPLER3D = 380, - USAMPLERCUBE = 381, - USAMPLER1DARRAY = 382, - USAMPLER2DARRAY = 383, - SAMPLER2DRECT = 384, - SAMPLER2DRECTSHADOW = 385, - ISAMPLER2DRECT = 386, - USAMPLER2DRECT = 387, - SAMPLERBUFFER = 388, - ISAMPLERBUFFER = 389, - USAMPLERBUFFER = 390, - SAMPLERCUBEARRAY = 391, - SAMPLERCUBEARRAYSHADOW = 392, - ISAMPLERCUBEARRAY = 393, - USAMPLERCUBEARRAY = 394, - SAMPLER2DMS = 395, - ISAMPLER2DMS = 396, - USAMPLER2DMS = 397, - SAMPLER2DMSARRAY = 398, - ISAMPLER2DMSARRAY = 399, - USAMPLER2DMSARRAY = 400, - SAMPLEREXTERNALOES = 401, - SAMPLER = 402, - SAMPLERSHADOW = 403, - TEXTURE1D = 404, - TEXTURE2D = 405, - TEXTURE3D = 406, - TEXTURECUBE = 407, - TEXTURE1DARRAY = 408, - TEXTURE2DARRAY = 409, - ITEXTURE1D = 410, - ITEXTURE2D = 411, - ITEXTURE3D = 412, - ITEXTURECUBE = 413, - ITEXTURE1DARRAY = 414, - ITEXTURE2DARRAY = 415, - UTEXTURE1D = 416, - UTEXTURE2D = 417, - UTEXTURE3D = 418, - UTEXTURECUBE = 419, - UTEXTURE1DARRAY = 420, - UTEXTURE2DARRAY = 421, - TEXTURE2DRECT = 422, - ITEXTURE2DRECT = 423, - UTEXTURE2DRECT = 424, - TEXTUREBUFFER = 425, - ITEXTUREBUFFER = 426, - UTEXTUREBUFFER = 427, - TEXTURECUBEARRAY = 428, - ITEXTURECUBEARRAY = 429, - UTEXTURECUBEARRAY = 430, - TEXTURE2DMS = 431, - ITEXTURE2DMS = 432, - UTEXTURE2DMS = 433, - TEXTURE2DMSARRAY = 434, - ITEXTURE2DMSARRAY = 435, - UTEXTURE2DMSARRAY = 436, - SUBPASSINPUT = 437, - SUBPASSINPUTMS = 438, - ISUBPASSINPUT = 439, - ISUBPASSINPUTMS = 440, - USUBPASSINPUT = 441, - USUBPASSINPUTMS = 442, - IMAGE1D = 443, - IIMAGE1D = 444, - UIMAGE1D = 445, - IMAGE2D = 446, - IIMAGE2D = 447, - UIMAGE2D = 448, - IMAGE3D = 449, - IIMAGE3D = 450, - UIMAGE3D = 451, - IMAGE2DRECT = 452, - IIMAGE2DRECT = 453, - UIMAGE2DRECT = 454, - IMAGECUBE = 455, - IIMAGECUBE = 456, - UIMAGECUBE = 457, - IMAGEBUFFER = 458, - IIMAGEBUFFER = 459, - UIMAGEBUFFER = 460, - IMAGE1DARRAY = 461, - IIMAGE1DARRAY = 462, - UIMAGE1DARRAY = 463, - IMAGE2DARRAY = 464, - IIMAGE2DARRAY = 465, - UIMAGE2DARRAY = 466, - IMAGECUBEARRAY = 467, - IIMAGECUBEARRAY = 468, - UIMAGECUBEARRAY = 469, - IMAGE2DMS = 470, - IIMAGE2DMS = 471, - UIMAGE2DMS = 472, - IMAGE2DMSARRAY = 473, - IIMAGE2DMSARRAY = 474, - UIMAGE2DMSARRAY = 475, - STRUCT = 476, - VOID = 477, - WHILE = 478, - IDENTIFIER = 479, - TYPE_NAME = 480, - FLOATCONSTANT = 481, - DOUBLECONSTANT = 482, - INTCONSTANT = 483, - UINTCONSTANT = 484, - INT64CONSTANT = 485, - UINT64CONSTANT = 486, - BOOLCONSTANT = 487, - FLOAT16CONSTANT = 488, - LEFT_OP = 489, - RIGHT_OP = 490, - INC_OP = 491, - DEC_OP = 492, - LE_OP = 493, - GE_OP = 494, - EQ_OP = 495, - NE_OP = 496, - AND_OP = 497, - OR_OP = 498, - XOR_OP = 499, - MUL_ASSIGN = 500, - DIV_ASSIGN = 501, - ADD_ASSIGN = 502, - MOD_ASSIGN = 503, - LEFT_ASSIGN = 504, - RIGHT_ASSIGN = 505, - AND_ASSIGN = 506, - XOR_ASSIGN = 507, - OR_ASSIGN = 508, - SUB_ASSIGN = 509, - LEFT_PAREN = 510, - RIGHT_PAREN = 511, - LEFT_BRACKET = 512, - RIGHT_BRACKET = 513, - LEFT_BRACE = 514, - RIGHT_BRACE = 515, - DOT = 516, - COMMA = 517, - COLON = 518, - EQUAL = 519, - SEMICOLON = 520, - BANG = 521, - DASH = 522, - TILDE = 523, - PLUS = 524, - STAR = 525, - SLASH = 526, - PERCENT = 527, - LEFT_ANGLE = 528, - RIGHT_ANGLE = 529, - VERTICAL_BAR = 530, - CARET = 531, - AMPERSAND = 532, - QUESTION = 533, - INVARIANT = 534, - PRECISE = 535, - HIGH_PRECISION = 536, - MEDIUM_PRECISION = 537, - LOW_PRECISION = 538, - PRECISION = 539, - PACKED = 540, - RESOURCE = 541, - SUPERP = 542 + INT16_T = 268, + UINT16_T = 269, + FLOAT16_T = 270, + BREAK = 271, + CONTINUE = 272, + DO = 273, + ELSE = 274, + FOR = 275, + IF = 276, + DISCARD = 277, + RETURN = 278, + SWITCH = 279, + CASE = 280, + DEFAULT = 281, + SUBROUTINE = 282, + BVEC2 = 283, + BVEC3 = 284, + BVEC4 = 285, + IVEC2 = 286, + IVEC3 = 287, + IVEC4 = 288, + I64VEC2 = 289, + I64VEC3 = 290, + I64VEC4 = 291, + UVEC2 = 292, + UVEC3 = 293, + UVEC4 = 294, + U64VEC2 = 295, + U64VEC3 = 296, + U64VEC4 = 297, + VEC2 = 298, + VEC3 = 299, + VEC4 = 300, + MAT2 = 301, + MAT3 = 302, + MAT4 = 303, + CENTROID = 304, + IN = 305, + OUT = 306, + INOUT = 307, + UNIFORM = 308, + PATCH = 309, + SAMPLE = 310, + BUFFER = 311, + SHARED = 312, + COHERENT = 313, + VOLATILE = 314, + RESTRICT = 315, + READONLY = 316, + WRITEONLY = 317, + DVEC2 = 318, + DVEC3 = 319, + DVEC4 = 320, + DMAT2 = 321, + DMAT3 = 322, + DMAT4 = 323, + F16VEC2 = 324, + F16VEC3 = 325, + F16VEC4 = 326, + F16MAT2 = 327, + F16MAT3 = 328, + F16MAT4 = 329, + I16VEC2 = 330, + I16VEC3 = 331, + I16VEC4 = 332, + U16VEC2 = 333, + U16VEC3 = 334, + U16VEC4 = 335, + NOPERSPECTIVE = 336, + FLAT = 337, + SMOOTH = 338, + LAYOUT = 339, + __EXPLICITINTERPAMD = 340, + MAT2X2 = 341, + MAT2X3 = 342, + MAT2X4 = 343, + MAT3X2 = 344, + MAT3X3 = 345, + MAT3X4 = 346, + MAT4X2 = 347, + MAT4X3 = 348, + MAT4X4 = 349, + DMAT2X2 = 350, + DMAT2X3 = 351, + DMAT2X4 = 352, + DMAT3X2 = 353, + DMAT3X3 = 354, + DMAT3X4 = 355, + DMAT4X2 = 356, + DMAT4X3 = 357, + DMAT4X4 = 358, + F16MAT2X2 = 359, + F16MAT2X3 = 360, + F16MAT2X4 = 361, + F16MAT3X2 = 362, + F16MAT3X3 = 363, + F16MAT3X4 = 364, + F16MAT4X2 = 365, + F16MAT4X3 = 366, + F16MAT4X4 = 367, + ATOMIC_UINT = 368, + SAMPLER1D = 369, + SAMPLER2D = 370, + SAMPLER3D = 371, + SAMPLERCUBE = 372, + SAMPLER1DSHADOW = 373, + SAMPLER2DSHADOW = 374, + SAMPLERCUBESHADOW = 375, + SAMPLER1DARRAY = 376, + SAMPLER2DARRAY = 377, + SAMPLER1DARRAYSHADOW = 378, + SAMPLER2DARRAYSHADOW = 379, + ISAMPLER1D = 380, + ISAMPLER2D = 381, + ISAMPLER3D = 382, + ISAMPLERCUBE = 383, + ISAMPLER1DARRAY = 384, + ISAMPLER2DARRAY = 385, + USAMPLER1D = 386, + USAMPLER2D = 387, + USAMPLER3D = 388, + USAMPLERCUBE = 389, + USAMPLER1DARRAY = 390, + USAMPLER2DARRAY = 391, + SAMPLER2DRECT = 392, + SAMPLER2DRECTSHADOW = 393, + ISAMPLER2DRECT = 394, + USAMPLER2DRECT = 395, + SAMPLERBUFFER = 396, + ISAMPLERBUFFER = 397, + USAMPLERBUFFER = 398, + SAMPLERCUBEARRAY = 399, + SAMPLERCUBEARRAYSHADOW = 400, + ISAMPLERCUBEARRAY = 401, + USAMPLERCUBEARRAY = 402, + SAMPLER2DMS = 403, + ISAMPLER2DMS = 404, + USAMPLER2DMS = 405, + SAMPLER2DMSARRAY = 406, + ISAMPLER2DMSARRAY = 407, + USAMPLER2DMSARRAY = 408, + SAMPLEREXTERNALOES = 409, + SAMPLER = 410, + SAMPLERSHADOW = 411, + TEXTURE1D = 412, + TEXTURE2D = 413, + TEXTURE3D = 414, + TEXTURECUBE = 415, + TEXTURE1DARRAY = 416, + TEXTURE2DARRAY = 417, + ITEXTURE1D = 418, + ITEXTURE2D = 419, + ITEXTURE3D = 420, + ITEXTURECUBE = 421, + ITEXTURE1DARRAY = 422, + ITEXTURE2DARRAY = 423, + UTEXTURE1D = 424, + UTEXTURE2D = 425, + UTEXTURE3D = 426, + UTEXTURECUBE = 427, + UTEXTURE1DARRAY = 428, + UTEXTURE2DARRAY = 429, + TEXTURE2DRECT = 430, + ITEXTURE2DRECT = 431, + UTEXTURE2DRECT = 432, + TEXTUREBUFFER = 433, + ITEXTUREBUFFER = 434, + UTEXTUREBUFFER = 435, + TEXTURECUBEARRAY = 436, + ITEXTURECUBEARRAY = 437, + UTEXTURECUBEARRAY = 438, + TEXTURE2DMS = 439, + ITEXTURE2DMS = 440, + UTEXTURE2DMS = 441, + TEXTURE2DMSARRAY = 442, + ITEXTURE2DMSARRAY = 443, + UTEXTURE2DMSARRAY = 444, + SUBPASSINPUT = 445, + SUBPASSINPUTMS = 446, + ISUBPASSINPUT = 447, + ISUBPASSINPUTMS = 448, + USUBPASSINPUT = 449, + USUBPASSINPUTMS = 450, + IMAGE1D = 451, + IIMAGE1D = 452, + UIMAGE1D = 453, + IMAGE2D = 454, + IIMAGE2D = 455, + UIMAGE2D = 456, + IMAGE3D = 457, + IIMAGE3D = 458, + UIMAGE3D = 459, + IMAGE2DRECT = 460, + IIMAGE2DRECT = 461, + UIMAGE2DRECT = 462, + IMAGECUBE = 463, + IIMAGECUBE = 464, + UIMAGECUBE = 465, + IMAGEBUFFER = 466, + IIMAGEBUFFER = 467, + UIMAGEBUFFER = 468, + IMAGE1DARRAY = 469, + IIMAGE1DARRAY = 470, + UIMAGE1DARRAY = 471, + IMAGE2DARRAY = 472, + IIMAGE2DARRAY = 473, + UIMAGE2DARRAY = 474, + IMAGECUBEARRAY = 475, + IIMAGECUBEARRAY = 476, + UIMAGECUBEARRAY = 477, + IMAGE2DMS = 478, + IIMAGE2DMS = 479, + UIMAGE2DMS = 480, + IMAGE2DMSARRAY = 481, + IIMAGE2DMSARRAY = 482, + UIMAGE2DMSARRAY = 483, + STRUCT = 484, + VOID = 485, + WHILE = 486, + IDENTIFIER = 487, + TYPE_NAME = 488, + FLOATCONSTANT = 489, + DOUBLECONSTANT = 490, + INTCONSTANT = 491, + UINTCONSTANT = 492, + INT64CONSTANT = 493, + UINT64CONSTANT = 494, + INT16CONSTANT = 495, + UINT16CONSTANT = 496, + BOOLCONSTANT = 497, + FLOAT16CONSTANT = 498, + LEFT_OP = 499, + RIGHT_OP = 500, + INC_OP = 501, + DEC_OP = 502, + LE_OP = 503, + GE_OP = 504, + EQ_OP = 505, + NE_OP = 506, + AND_OP = 507, + OR_OP = 508, + XOR_OP = 509, + MUL_ASSIGN = 510, + DIV_ASSIGN = 511, + ADD_ASSIGN = 512, + MOD_ASSIGN = 513, + LEFT_ASSIGN = 514, + RIGHT_ASSIGN = 515, + AND_ASSIGN = 516, + XOR_ASSIGN = 517, + OR_ASSIGN = 518, + SUB_ASSIGN = 519, + LEFT_PAREN = 520, + RIGHT_PAREN = 521, + LEFT_BRACKET = 522, + RIGHT_BRACKET = 523, + LEFT_BRACE = 524, + RIGHT_BRACE = 525, + DOT = 526, + COMMA = 527, + COLON = 528, + EQUAL = 529, + SEMICOLON = 530, + BANG = 531, + DASH = 532, + TILDE = 533, + PLUS = 534, + STAR = 535, + SLASH = 536, + PERCENT = 537, + LEFT_ANGLE = 538, + RIGHT_ANGLE = 539, + VERTICAL_BAR = 540, + CARET = 541, + AMPERSAND = 542, + QUESTION = 543, + INVARIANT = 544, + PRECISE = 545, + HIGH_PRECISION = 546, + MEDIUM_PRECISION = 547, + LOW_PRECISION = 548, + PRECISION = 549, + PACKED = 550, + RESOURCE = 551, + SUPERP = 552 }; #endif @@ -372,7 +382,7 @@ union YYSTYPE }; } interm; -#line 376 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909 */ +#line 386 "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 59faba8b..7d0f1554 100644 --- a/glslang/MachineIndependent/intermOut.cpp +++ b/glslang/MachineIndependent/intermOut.cpp @@ -308,6 +308,13 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node) case EOpDoubleBitsToUint64: out.debug << "doubleBitsToUint64"; break; case EOpInt64BitsToDouble: out.debug << "int64BitsToDouble"; break; case EOpUint64BitsToDouble: out.debug << "uint64BitsToDouble"; break; +#ifdef AMD_EXTENSIONS + case EOpFloat16BitsToInt16: out.debug << "float16BitsToInt16"; break; + case EOpFloat16BitsToUint16: out.debug << "float16BitsToUint16"; break; + case EOpInt16BitsToFloat16: out.debug << "int16BitsToFloat16"; break; + case EOpUint16BitsToFloat16: out.debug << "uint16BitsToFloat16"; break; +#endif + case EOpPackSnorm2x16: out.debug << "packSnorm2x16"; break; case EOpUnpackSnorm2x16:out.debug << "unpackSnorm2x16"; break; case EOpPackUnorm2x16: out.debug << "packUnorm2x16"; break; @@ -328,6 +335,16 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node) case EOpUnpackUint2x32: out.debug << "unpackUint2x32"; break; #ifdef AMD_EXTENSIONS + case EOpPackInt2x16: out.debug << "packInt2x16"; break; + case EOpUnpackInt2x16: out.debug << "unpackInt2x16"; break; + case EOpPackUint2x16: out.debug << "packUint2x16"; break; + case EOpUnpackUint2x16: out.debug << "unpackUint2x16"; break; + + case EOpPackInt4x16: out.debug << "packInt4x16"; break; + case EOpUnpackInt4x16: out.debug << "unpackInt4x16"; break; + case EOpPackUint4x16: out.debug << "packUint4x16"; break; + case EOpUnpackUint4x16: out.debug << "unpackUint4x16"; break; + case EOpPackFloat2x16: out.debug << "packFloat2x16"; break; case EOpUnpackFloat2x16: out.debug << "unpackFloat2x16"; break; #endif @@ -433,6 +450,42 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node) case EOpConvFloat16ToDouble: out.debug << "Convert float16 to double"; break; case EOpConvFloat16ToInt64: out.debug << "Convert float16 to int64"; break; case EOpConvFloat16ToUint64: out.debug << "Convert float16 to uint64"; break; + + case EOpConvBoolToInt16: out.debug << "Convert bool to int16"; break; + case EOpConvIntToInt16: out.debug << "Convert int to int16"; break; + case EOpConvUintToInt16: out.debug << "Convert uint to int16"; break; + case EOpConvFloatToInt16: out.debug << "Convert float to int16"; break; + case EOpConvDoubleToInt16: out.debug << "Convert double to int16"; break; + case EOpConvFloat16ToInt16: out.debug << "Convert float16 to int16"; break; + case EOpConvInt64ToInt16: out.debug << "Convert int64 to int16"; break; + case EOpConvUint64ToInt16: out.debug << "Convert uint64 to int16"; break; + case EOpConvUint16ToInt16: out.debug << "Convert uint16 to int16"; break; + case EOpConvInt16ToBool: out.debug << "Convert int16 to bool"; break; + case EOpConvInt16ToInt: out.debug << "Convert int16 to int"; break; + case EOpConvInt16ToUint: out.debug << "Convert int16 to uint"; break; + case EOpConvInt16ToFloat: out.debug << "Convert int16 to float"; break; + case EOpConvInt16ToDouble: out.debug << "Convert int16 to double"; break; + case EOpConvInt16ToFloat16: out.debug << "Convert int16 to float16"; break; + case EOpConvInt16ToInt64: out.debug << "Convert int16 to int64"; break; + case EOpConvInt16ToUint64: out.debug << "Convert int16 to uint64"; break; + + case EOpConvBoolToUint16: out.debug << "Convert bool to uint16"; break; + case EOpConvIntToUint16: out.debug << "Convert int to uint16"; break; + case EOpConvUintToUint16: out.debug << "Convert uint to uint16"; break; + case EOpConvFloatToUint16: out.debug << "Convert float to uint16"; break; + case EOpConvDoubleToUint16: out.debug << "Convert double to uint16"; break; + case EOpConvFloat16ToUint16: out.debug << "Convert float16 to uint16"; break; + case EOpConvInt64ToUint16: out.debug << "Convert int64 to uint16"; break; + case EOpConvUint64ToUint16: out.debug << "Convert uint64 to uint16"; break; + case EOpConvInt16ToUint16: out.debug << "Convert int16 to uint16"; break; + case EOpConvUint16ToBool: out.debug << "Convert uint16 to bool"; break; + case EOpConvUint16ToInt: out.debug << "Convert uint16 to int"; break; + case EOpConvUint16ToUint: out.debug << "Convert uint16 to uint"; break; + case EOpConvUint16ToFloat: out.debug << "Convert uint16 to float"; break; + case EOpConvUint16ToDouble: out.debug << "Convert uint16 to double"; break; + case EOpConvUint16ToFloat16: out.debug << "Convert uint16 to float16"; break; + case EOpConvUint16ToInt64: out.debug << "Convert uint16 to int64"; break; + case EOpConvUint16ToUint64: out.debug << "Convert uint16 to uint64"; break; #endif default: out.debug.message(EPrefixError, "Bad unary op"); @@ -466,9 +519,13 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpConstructFloat: out.debug << "Construct float"; break; case EOpConstructDouble:out.debug << "Construct double"; break; + case EOpConstructVec2: out.debug << "Construct vec2"; break; case EOpConstructVec3: out.debug << "Construct vec3"; break; case EOpConstructVec4: out.debug << "Construct vec4"; break; + case EOpConstructDVec2: out.debug << "Construct dvec2"; break; + case EOpConstructDVec3: out.debug << "Construct dvec3"; break; + case EOpConstructDVec4: out.debug << "Construct dvec4"; break; case EOpConstructBool: out.debug << "Construct bool"; break; case EOpConstructBVec2: out.debug << "Construct bvec2"; break; case EOpConstructBVec3: out.debug << "Construct bvec3"; break; @@ -489,6 +546,16 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpConstructU64Vec2: out.debug << "Construct u64vec2"; break; case EOpConstructU64Vec3: out.debug << "Construct u64vec3"; break; case EOpConstructU64Vec4: out.debug << "Construct u64vec4"; break; +#ifdef AMD_EXTENSIONS + case EOpConstructInt16: out.debug << "Construct int16_t"; break; + case EOpConstructI16Vec2: out.debug << "Construct i16vec2"; break; + case EOpConstructI16Vec3: out.debug << "Construct i16vec3"; break; + case EOpConstructI16Vec4: out.debug << "Construct i16vec4"; break; + case EOpConstructUint16: out.debug << "Construct uint16_t"; break; + case EOpConstructU16Vec2: out.debug << "Construct u16vec2"; break; + case EOpConstructU16Vec3: out.debug << "Construct u16vec3"; break; + case EOpConstructU16Vec4: out.debug << "Construct u16vec4"; break; +#endif case EOpConstructMat2x2: out.debug << "Construct mat2"; break; case EOpConstructMat2x3: out.debug << "Construct mat2x3"; break; case EOpConstructMat2x4: out.debug << "Construct mat2x4"; break; @@ -827,6 +894,26 @@ static void OutputConstantUnion(TInfoSink& out, const TIntermTyped* node, const out.debug << buf << "\n"; } break; +#ifdef AMD_EXTENSIONS + case EbtInt16: + { + const int maxSize = 300; + char buf[maxSize]; + snprintf(buf, maxSize, "%d (%s)", constUnion[i].getIConst(), "const int16_t"); + + out.debug << buf << "\n"; + } + break; + case EbtUint16: + { + const int maxSize = 300; + char buf[maxSize]; + snprintf(buf, maxSize, "%u (%s)", constUnion[i].getUConst(), "const uint16_t"); + + out.debug << buf << "\n"; + } + break; +#endif default: out.info.message(EPrefixInternalError, "Unknown constant", node->getLoc()); break; diff --git a/glslang/MachineIndependent/linkValidate.cpp b/glslang/MachineIndependent/linkValidate.cpp index 02dde9ef..4a91a252 100644 --- a/glslang/MachineIndependent/linkValidate.cpp +++ b/glslang/MachineIndependent/linkValidate.cpp @@ -1057,6 +1057,8 @@ int TIntermediate::getBaseAlignmentScalar(const TType& type, int& size) case EbtUint64: case EbtDouble: size = 8; return 8; #ifdef AMD_EXTENSIONS + case EbtInt16: + case EbtUint16: case EbtFloat16: size = 2; return 2; #endif default: size = 4; return 4; diff --git a/glslang/MachineIndependent/localintermediate.h b/glslang/MachineIndependent/localintermediate.h index 56319dc6..f93182b7 100644 --- a/glslang/MachineIndependent/localintermediate.h +++ b/glslang/MachineIndependent/localintermediate.h @@ -285,6 +285,11 @@ public: TIntermConstantUnion* addConstantUnion(unsigned int, const TSourceLoc&, bool literal = false) const; TIntermConstantUnion* addConstantUnion(long long, const TSourceLoc&, bool literal = false) const; TIntermConstantUnion* addConstantUnion(unsigned long long, const TSourceLoc&, bool literal = false) const; +#ifdef AMD_EXTENSIONS + TIntermConstantUnion* addConstantUnion(short, const TSourceLoc&, bool literal = false) const; + TIntermConstantUnion* addConstantUnion(unsigned short, const TSourceLoc&, bool literal = false) const; + +#endif TIntermConstantUnion* addConstantUnion(bool, const TSourceLoc&, bool literal = false) const; TIntermConstantUnion* addConstantUnion(double, TBasicType, const TSourceLoc&, bool literal = false) const; TIntermConstantUnion* addConstantUnion(const TString*, const TSourceLoc&, bool literal = false) const; diff --git a/glslang/MachineIndependent/parseVersions.h b/glslang/MachineIndependent/parseVersions.h index 3cd691ea..5f26b437 100755 --- a/glslang/MachineIndependent/parseVersions.h +++ b/glslang/MachineIndependent/parseVersions.h @@ -78,6 +78,7 @@ public: virtual void fullIntegerCheck(const TSourceLoc&, const char* op); virtual void doubleCheck(const TSourceLoc&, const char* op); #ifdef AMD_EXTENSIONS + virtual void int16Check(const TSourceLoc& loc, const char* op, bool builtIn = false); virtual void float16Check(const TSourceLoc&, const char* op, bool builtIn = false); #endif virtual void int64Check(const TSourceLoc&, const char* op, bool builtIn = false); diff --git a/glslang/MachineIndependent/preprocessor/Pp.cpp b/glslang/MachineIndependent/preprocessor/Pp.cpp index 34a9299b..92423507 100644 --- a/glslang/MachineIndependent/preprocessor/Pp.cpp +++ b/glslang/MachineIndependent/preprocessor/Pp.cpp @@ -724,6 +724,7 @@ int TPpContext::CPPerror(TPpToken* ppToken) if (token == PpAtomConstInt || token == PpAtomConstUint || token == PpAtomConstInt64 || token == PpAtomConstUint64 || #ifdef AMD_EXTENSIONS + token == PpAtomConstInt16 || token == PpAtomConstUint16 || token == PpAtomConstFloat16 || #endif token == PpAtomConstFloat || token == PpAtomConstDouble) { @@ -758,6 +759,10 @@ int TPpContext::CPPpragma(TPpToken* ppToken) case PpAtomConstUint: case PpAtomConstInt64: case PpAtomConstUint64: +#ifdef AMD_EXTENSIONS + case PpAtomConstInt16: + case PpAtomConstUint16: +#endif case PpAtomConstFloat: case PpAtomConstDouble: #ifdef AMD_EXTENSIONS diff --git a/glslang/MachineIndependent/preprocessor/PpScanner.cpp b/glslang/MachineIndependent/preprocessor/PpScanner.cpp index cee45ce7..fa01549d 100644 --- a/glslang/MachineIndependent/preprocessor/PpScanner.cpp +++ b/glslang/MachineIndependent/preprocessor/PpScanner.cpp @@ -334,6 +334,9 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) int ii = 0; unsigned long long ival = 0; bool enableInt64 = pp->parseContext.version >= 450 && pp->parseContext.extensionTurnedOn(E_GL_ARB_gpu_shader_int64); +#ifdef AMD_EXTENSIONS + bool enableInt16 = pp->parseContext.version >= 450 && pp->parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_int16); +#endif bool acceptHalf = pp->parseContext.intermediate.getSource() == EShSourceHlsl; #ifdef AMD_EXTENSIONS if (pp->parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float)) @@ -406,6 +409,9 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) bool isUnsigned = false; bool isInt64 = false; +#ifdef AMD_EXTENSIONS + bool isInt16 = false; +#endif ppToken->name[len++] = (char)ch; ch = getch(); if ((ch >= '0' && ch <= '9') || @@ -414,7 +420,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) ival = 0; do { - if (ival <= 0x0fffffff || (enableInt64 && ival <= 0x0fffffffffffffffull)) { + if (ival <= 0x0fffffffu || (enableInt64 && ival <= 0x0fffffffffffffffull)) { ppToken->name[len++] = (char)ch; if (ch >= '0' && ch <= '9') { ii = ch - '0'; @@ -453,11 +459,28 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) } else ungetch(); } - } - else if (enableInt64 && (ch == 'l' || ch == 'L')) { + +#ifdef AMD_EXTENSIONS + if (enableInt16) { + int nextCh = getch(); + if ((ch == 'u' && nextCh == 's') || (ch == 'U' && nextCh == 'S')) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)nextCh; + isInt16 = true; + } else + ungetch(); + } +#endif + } else if (enableInt64 && (ch == 'l' || ch == 'L')) { if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; isInt64 = true; +#ifdef AMD_EXTENSIONS + } else if (enableInt16 && (ch == 's' || ch == 'S')) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)ch; + isInt16 = true; +#endif } else ungetch(); ppToken->name[len] = '\0'; @@ -465,6 +488,11 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) if (isInt64) { ppToken->i64val = ival; return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64; +#ifdef AMD_EXTENSIONS + } else if (isInt16) { + ppToken->ival = (int)ival; + return isUnsigned ? PpAtomConstUint16 : PpAtomConstInt16; +#endif } else { ppToken->ival = (int)ival; return isUnsigned ? PpAtomConstUint : PpAtomConstInt; @@ -474,6 +502,9 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) bool isUnsigned = false; bool isInt64 = false; +#ifdef AMD_EXTENSIONS + bool isInt16 = false; +#endif bool octalOverflow = false; bool nonOctal = false; ival = 0; @@ -486,7 +517,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) pp->parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); AlreadyComplained = 1; } - if (ival <= 0x1fffffff || (enableInt64 && ival <= 0x1fffffffffffffffull)) { + if (ival <= 0x1fffffffu || (enableInt64 && ival <= 0x1fffffffffffffffull)) { ii = ch - '0'; ival = (ival << 3) | ii; } else @@ -528,11 +559,28 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) } else ungetch(); } - } - else if (enableInt64 && (ch == 'l' || ch == 'L')) { + +#ifdef AMD_EXTENSIONS + if (enableInt16) { + int nextCh = getch(); + if ((ch == 'u' && nextCh == 's') || (ch == 'U' && nextCh == 'S')) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)nextCh; + isInt16 = true; + } else + ungetch(); + } +#endif + } else if (enableInt64 && (ch == 'l' || ch == 'L')) { if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; isInt64 = true; +#ifdef AMD_EXTENSIONS + } else if (enableInt16 && (ch == 's' || ch == 'S')) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)ch; + isInt16 = true; +#endif } else ungetch(); ppToken->name[len] = '\0'; @@ -543,6 +591,11 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) if (isInt64) { ppToken->i64val = ival; return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64; +#ifdef AMD_EXTENSIONS + } else if (isInt16) { + ppToken->ival = (int)ival; + return isUnsigned ? PpAtomConstUint16 : PpAtomConstInt16; +#endif } else { ppToken->ival = (int)ival; return isUnsigned ? PpAtomConstUint : PpAtomConstInt; @@ -569,6 +622,9 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) int numericLen = len; bool isUnsigned = false; bool isInt64 = false; +#ifdef AMD_EXTENSIONS + bool isInt16 = false; +#endif if (ch == 'u' || ch == 'U') { if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; @@ -583,10 +639,28 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) } else ungetch(); } + +#ifdef AMD_EXTENSIONS + if (enableInt16) { + int nextCh = getch(); + if ((ch == 'u' && nextCh == 's') || (ch == 'U' && nextCh == 'S')) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)nextCh; + isInt16 = true; + } else + ungetch(); + } +#endif } else if (enableInt64 && (ch == 'l' || ch == 'L')) { if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; isInt64 = true; +#ifdef AMD_EXTENSIONS + } else if (enableInt16 && (ch == 's' || ch == 'S')) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)ch; + isInt16 = true; +#endif } else ungetch(); @@ -596,10 +670,22 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) const unsigned remainderMaxInt = 0xFFFFFFFFu - 10 * oneTenthMaxInt; const unsigned long long oneTenthMaxInt64 = 0xFFFFFFFFFFFFFFFFull / 10; const unsigned long long remainderMaxInt64 = 0xFFFFFFFFFFFFFFFFull - 10 * oneTenthMaxInt64; +#ifdef AMD_EXTENSIONS + const unsigned short oneTenthMaxInt16 = 0xFFFFu / 10; + const unsigned short remainderMaxInt16 = 0xFFFFu - 10 * oneTenthMaxInt16; +#endif for (int i = 0; i < numericLen; i++) { ch = ppToken->name[i] - '0'; - if ((enableInt64 == false && ((ival > oneTenthMaxInt) || (ival == oneTenthMaxInt && (unsigned)ch > remainderMaxInt))) || - (enableInt64 && ((ival > oneTenthMaxInt64) || (ival == oneTenthMaxInt64 && (unsigned long long)ch > remainderMaxInt64)))) { + bool overflow = false; + if (isInt64) + overflow = (ival > oneTenthMaxInt64 || (ival == oneTenthMaxInt64 && (unsigned long long)ch > remainderMaxInt64)); +#ifdef AMD_EXTENSIONS + else if (isInt16) + overflow = (ival > oneTenthMaxInt16 || (ival == oneTenthMaxInt16 && (unsigned short)ch > remainderMaxInt16)); +#endif + else + overflow = (ival > oneTenthMaxInt || (ival == oneTenthMaxInt && (unsigned)ch > remainderMaxInt)); + if (overflow) { pp->parseContext.ppError(ppToken->loc, "numeric literal too big", "", ""); ival = 0xFFFFFFFFFFFFFFFFull; break; @@ -610,6 +696,11 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) if (isInt64) { ppToken->i64val = ival; return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64; +#ifdef AMD_EXTENSIONS + } else if (isInt16) { + ppToken->ival = (int)ival; + return isUnsigned ? PpAtomConstUint16 : PpAtomConstInt16; +#endif } else { ppToken->ival = (int)ival; return isUnsigned ? PpAtomConstUint : PpAtomConstInt; @@ -859,6 +950,10 @@ int TPpContext::tokenize(TPpToken& ppToken) case PpAtomConstFloat: case PpAtomConstInt64: case PpAtomConstUint64: +#ifdef AMD_EXTENSIONS + case PpAtomConstInt16: + case PpAtomConstUint16: +#endif case PpAtomConstDouble: #ifdef AMD_EXTENSIONS case PpAtomConstFloat16: diff --git a/glslang/MachineIndependent/preprocessor/PpTokens.cpp b/glslang/MachineIndependent/preprocessor/PpTokens.cpp index 4baf99e0..bc145e25 100644 --- a/glslang/MachineIndependent/preprocessor/PpTokens.cpp +++ b/glslang/MachineIndependent/preprocessor/PpTokens.cpp @@ -141,6 +141,10 @@ void TPpContext::TokenStream::putToken(int token, TPpToken* ppToken) case PpAtomConstUint: case PpAtomConstInt64: case PpAtomConstUint64: +#ifdef AMD_EXTENSIONS + case PpAtomConstInt16: + case PpAtomConstUint16: +#endif case PpAtomConstFloat: case PpAtomConstDouble: #ifdef AMD_EXTENSIONS @@ -190,6 +194,10 @@ int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken case PpAtomConstUint: case PpAtomConstInt64: case PpAtomConstUint64: +#ifdef AMD_EXTENSIONS + case PpAtomConstInt16: + case PpAtomConstUint16: +#endif len = 0; ch = getSubtoken(); while (ch != 0 && ch != EndOfInput) { @@ -217,6 +225,9 @@ int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken ppToken->dval = atof(ppToken->name); break; case PpAtomConstInt: +#ifdef AMD_EXTENSIONS + case PpAtomConstInt16: +#endif if (len > 0 && ppToken->name[0] == '0') { if (len > 1 && (ppToken->name[1] == 'x' || ppToken->name[1] == 'X')) ppToken->ival = (int)strtol(ppToken->name, 0, 16); @@ -226,6 +237,9 @@ int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken ppToken->ival = atoi(ppToken->name); break; case PpAtomConstUint: +#ifdef AMD_EXTENSIONS + case PpAtomConstUint16: +#endif if (len > 0 && ppToken->name[0] == '0') { if (len > 1 && (ppToken->name[1] == 'x' || ppToken->name[1] == 'X')) ppToken->ival = (int)strtoul(ppToken->name, 0, 16); diff --git a/glslang/MachineIndependent/preprocessor/PpTokens.h b/glslang/MachineIndependent/preprocessor/PpTokens.h index ee442d68..d56df576 100644 --- a/glslang/MachineIndependent/preprocessor/PpTokens.h +++ b/glslang/MachineIndependent/preprocessor/PpTokens.h @@ -127,6 +127,10 @@ enum EFixedAtoms { PpAtomConstUint, PpAtomConstInt64, PpAtomConstUint64, +#ifdef AMD_EXTENSIONS + PpAtomConstInt16, + PpAtomConstUint16, +#endif PpAtomConstFloat, PpAtomConstDouble, PpAtomConstFloat16, diff --git a/gtests/Spv.FromFile.cpp b/gtests/Spv.FromFile.cpp index 27b68378..dc91486e 100644 --- a/gtests/Spv.FromFile.cpp +++ b/gtests/Spv.FromFile.cpp @@ -396,6 +396,7 @@ INSTANTIATE_TEST_CASE_P( Glsl, CompileVulkanToSpirvTestAMD, ::testing::ValuesIn(std::vector({ "spv.float16.frag", + "spv.int16.frag", "spv.shaderBallotAMD.comp", "spv.textureGatherBiasLod.frag" })),