diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp index 07ed51cf..0c62d52e 100755 --- a/SPIRV/GlslangToSpv.cpp +++ b/SPIRV/GlslangToSpv.cpp @@ -1069,9 +1069,13 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI case glslang::EOpPreDecrement: { // we need the integer value "1" or the floating point "1.0" to add/subtract - spv::Id one = node->getBasicType() == glslang::EbtFloat ? - builder.makeFloatConstant(1.0F) : - builder.makeIntConstant(1); + spv::Id one = 0; + if (node->getBasicType() == glslang::EbtFloat) + one = builder.makeFloatConstant(1.0F); + else if (node->getBasicType() == glslang::EbtInt64 || node->getBasicType() == glslang::EbtUint64) + one = builder.makeInt64Constant(1); + else + one = builder.makeIntConstant(1); glslang::TOperator op; if (node->getOp() == glslang::EOpPreIncrement || node->getOp() == glslang::EOpPostIncrement) @@ -1080,8 +1084,8 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI op = glslang::EOpSub; spv::Id result = createBinaryOperation(op, TranslatePrecisionDecoration(node->getType()), - convertGlslangToSpvType(node->getType()), operand, one, - node->getType().getBasicType()); + convertGlslangToSpvType(node->getType()), operand, one, + node->getType().getBasicType()); assert(result != spv::NoResult); // The result of operation is always stored, but conditionally the @@ -1260,6 +1264,14 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt case glslang::EOpConstructUVec2: case glslang::EOpConstructUVec3: case glslang::EOpConstructUVec4: + case glslang::EOpConstructInt64: + case glslang::EOpConstructI64Vec2: + case glslang::EOpConstructI64Vec3: + case glslang::EOpConstructI64Vec4: + case glslang::EOpConstructUint64: + case glslang::EOpConstructU64Vec2: + case glslang::EOpConstructU64Vec3: + case glslang::EOpConstructU64Vec4: case glslang::EOpConstructStruct: case glslang::EOpConstructTextureSampler: { @@ -1740,6 +1752,14 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty case glslang::EbtUint: 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; case glslang::EbtAtomicUint: spv::TbdFunctionality("Is atomic_uint an opaque handle in the uniform storage class, or an addresses in the atomic storage class?"); spvType = builder.makeUintType(32); @@ -2631,7 +2651,7 @@ 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; + bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64; bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble; bool isBool = typeProxy == glslang::EbtBool; @@ -2948,7 +2968,7 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, spv: { spv::Op unaryOp = spv::OpNop; int libCall = -1; - bool isUnsigned = typeProxy == glslang::EbtUint; + bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64; bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble; switch (op) { @@ -3079,6 +3099,10 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, spv: case glslang::EOpFloatBitsToUint: case glslang::EOpIntBitsToFloat: case glslang::EOpUintBitsToFloat: + case glslang::EOpDoubleBitsToInt64: + case glslang::EOpDoubleBitsToUint64: + case glslang::EOpInt64BitsToDouble: + case glslang::EOpUint64BitsToDouble: unaryOp = spv::OpBitcast; break; @@ -3119,6 +3143,14 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, spv: libCall = spv::GLSLstd450UnpackDouble2x32; break; + case glslang::EOpPackInt2x32: + case glslang::EOpUnpackInt2x32: + case glslang::EOpPackUint2x32: + case glslang::EOpUnpackUint2x32: + spv::MissingFunctionality("shader int64"); + libCall = spv::GLSLstd450Bad; // TODO: This is a placeholder. + break; + case glslang::EOpDPdx: unaryOp = spv::OpDPdx; break; @@ -3252,13 +3284,17 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec spv::Op convOp = spv::OpNop; spv::Id zero = 0; spv::Id one = 0; + spv::Id type = 0; int vectorSize = builder.isVectorType(destType) ? builder.getNumTypeComponents(destType) : 0; switch (op) { case glslang::EOpConvIntToBool: case glslang::EOpConvUintToBool: - zero = builder.makeUintConstant(0); + case glslang::EOpConvInt64ToBool: + case glslang::EOpConvUint64ToBool: + zero = (op == glslang::EOpConvInt64ToBool || + op == glslang::EOpConvUint64ToBool) ? builder.makeUint64Constant(0) : builder.makeUintConstant(0); zero = makeSmearedConstant(zero, vectorSize); return builder.createBinOp(spv::OpINotEqual, destType, operand, zero); @@ -3283,23 +3319,29 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec one = builder.makeDoubleConstant(1.0); break; case glslang::EOpConvBoolToInt: - zero = builder.makeIntConstant(0); - one = builder.makeIntConstant(1); + case glslang::EOpConvBoolToInt64: + zero = (op == glslang::EOpConvBoolToInt64) ? builder.makeInt64Constant(0) : builder.makeIntConstant(0); + one = (op == glslang::EOpConvBoolToInt64) ? builder.makeInt64Constant(1) : builder.makeIntConstant(1); convOp = spv::OpSelect; break; case glslang::EOpConvBoolToUint: - zero = builder.makeUintConstant(0); - one = builder.makeUintConstant(1); + case glslang::EOpConvBoolToUint64: + zero = (op == glslang::EOpConvBoolToUint64) ? builder.makeUint64Constant(0) : builder.makeUintConstant(0); + one = (op == glslang::EOpConvBoolToUint64) ? builder.makeUint64Constant(1) : builder.makeUintConstant(1); convOp = spv::OpSelect; break; case glslang::EOpConvIntToFloat: case glslang::EOpConvIntToDouble: + case glslang::EOpConvInt64ToFloat: + case glslang::EOpConvInt64ToDouble: convOp = spv::OpConvertSToF; break; case glslang::EOpConvUintToFloat: case glslang::EOpConvUintToDouble: + case glslang::EOpConvUint64ToFloat: + case glslang::EOpConvUint64ToDouble: convOp = spv::OpConvertUToF; break; @@ -3310,14 +3352,19 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec case glslang::EOpConvFloatToInt: case glslang::EOpConvDoubleToInt: + case glslang::EOpConvFloatToInt64: + case glslang::EOpConvDoubleToInt64: convOp = spv::OpConvertFToS; break; case glslang::EOpConvUintToInt: case glslang::EOpConvIntToUint: + case glslang::EOpConvUint64ToInt64: + case glslang::EOpConvInt64ToUint64: if (builder.isInSpecConstCodeGenMode()) { // Build zero scalar or vector for OpIAdd. - zero = builder.makeUintConstant(0); + zero = (op == glslang::EOpConvUintToInt64 || + op == glslang::EOpConvIntToUint64) ? builder.makeUint64Constant(0) : builder.makeUintConstant(0); zero = makeSmearedConstant(zero, vectorSize); // Use OpIAdd, instead of OpBitcast to do the conversion when // generating for OpSpecConstantOp instruction. @@ -3329,8 +3376,65 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec case glslang::EOpConvFloatToUint: case glslang::EOpConvDoubleToUint: + case glslang::EOpConvFloatToUint64: + case glslang::EOpConvDoubleToUint64: convOp = spv::OpConvertFToU; break; + + case glslang::EOpConvIntToInt64: + case glslang::EOpConvInt64ToInt: + convOp = spv::OpSConvert; + break; + + case glslang::EOpConvUintToUint64: + case glslang::EOpConvUint64ToUint: + convOp = spv::OpUConvert; + break; + + case glslang::EOpConvIntToUint64: + case glslang::EOpConvInt64ToUint: + case glslang::EOpConvUint64ToInt: + case glslang::EOpConvUintToInt64: + // OpSConvert/OpUConvert + OpBitCast + switch (op) { + case glslang::EOpConvIntToUint64: + convOp = spv::OpSConvert; + type = builder.makeIntType(64); + break; + case glslang::EOpConvInt64ToUint: + convOp = spv::OpSConvert; + type = builder.makeIntType(32); + break; + case glslang::EOpConvUint64ToInt: + convOp = spv::OpUConvert; + type = builder.makeUintType(32); + break; + case glslang::EOpConvUintToInt64: + convOp = spv::OpUConvert; + type = builder.makeUintType(64); + break; + default: + assert(0); + break; + } + + if (vectorSize > 0) + type = builder.makeVectorType(type, vectorSize); + + operand = builder.createUnaryOp(convOp, type, operand); + + if (builder.isInSpecConstCodeGenMode()) { + // Build zero scalar or vector for OpIAdd. + zero = (op == glslang::EOpConvIntToUint64 || + op == glslang::EOpConvUintToInt64) ? builder.makeUint64Constant(0) : builder.makeUintConstant(0); + zero = makeSmearedConstant(zero, vectorSize); + // Use OpIAdd, instead of OpBitcast to do the conversion when + // generating for OpSpecConstantOp instruction. + return builder.createBinOp(spv::OpIAdd, destType, operand, zero); + } + // For normal run-time conversion instruction, use OpBitcast. + convOp = spv::OpBitcast; + break; default: break; } @@ -3441,7 +3545,7 @@ spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator 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; + bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64; bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble; spv::Op opCode = spv::OpNop; @@ -3876,6 +3980,12 @@ spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glsla case glslang::EbtUint: spvConsts.push_back(builder.makeUintConstant(zero ? 0 : consts[nextConst].getUConst())); break; + case glslang::EbtInt64: + spvConsts.push_back(builder.makeInt64Constant(zero ? 0 : consts[nextConst].getI64Const())); + break; + case glslang::EbtUint64: + spvConsts.push_back(builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const())); + break; case glslang::EbtFloat: spvConsts.push_back(builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst())); break; @@ -3902,6 +4012,12 @@ spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glsla case glslang::EbtUint: scalar = builder.makeUintConstant(zero ? 0 : consts[nextConst].getUConst(), specConstant); break; + case glslang::EbtInt64: + scalar = builder.makeInt64Constant(zero ? 0 : consts[nextConst].getI64Const(), specConstant); + break; + case glslang::EbtUint64: + scalar = builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const(), specConstant); + break; case glslang::EbtFloat: scalar = builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant); break; diff --git a/SPIRV/SpvBuilder.cpp b/SPIRV/SpvBuilder.cpp index bbb30c35..0171b15e 100644 --- a/SPIRV/SpvBuilder.cpp +++ b/SPIRV/SpvBuilder.cpp @@ -606,7 +606,7 @@ Id Builder::findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned valu return 0; } -// Version of findScalarConstant (see above) for scalars that take two operands (e.g. a 'double'). +// Version of findScalarConstant (see above) for scalars that take two operands (e.g. a 'double' or 'int64'). Id Builder::findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned v1, unsigned v2) const { Instruction* constant; @@ -711,6 +711,31 @@ Id Builder::makeIntConstant(Id typeId, unsigned value, bool specConstant) return c->getResultId(); } +Id Builder::makeInt64Constant(Id typeId, unsigned long long value, bool specConstant) +{ + Op opcode = specConstant ? OpSpecConstant : OpConstant; + + unsigned op1 = value & 0xFFFFFFFF; + unsigned op2 = value >> 32; + + // See if we already made it. Applies only to regular constants, because specialization constants + // must remain distinct for the purpose of applying a SpecId decoration. + if (! specConstant) { + Id existing = findScalarConstant(OpTypeInt, opcode, typeId, op1, op2); + if (existing) + return existing; + } + + Instruction* c = new Instruction(getUniqueId(), typeId, opcode); + c->addImmediateOperand(op1); + c->addImmediateOperand(op2); + constantsTypesGlobals.push_back(std::unique_ptr(c)); + groupedConstants[OpTypeInt].push_back(c); + module.mapInstruction(c); + + return c->getResultId(); +} + Id Builder::makeFloatConstant(float f, bool specConstant) { Op opcode = specConstant ? OpSpecConstant : OpConstant; diff --git a/SPIRV/SpvBuilder.h b/SPIRV/SpvBuilder.h index 661bb115..8c05f4e5 100755 --- a/SPIRV/SpvBuilder.h +++ b/SPIRV/SpvBuilder.h @@ -188,6 +188,8 @@ public: Id makeBoolConstant(bool b, bool specConstant = false); Id makeIntConstant(int i, bool specConstant = false) { return makeIntConstant(makeIntType(32), (unsigned)i, specConstant); } 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); } Id makeFloatConstant(float f, bool specConstant = false); Id makeDoubleConstant(double d, bool specConstant = false); @@ -533,6 +535,7 @@ public: protected: Id makeIntConstant(Id typeId, unsigned value, bool specConstant); + Id makeInt64Constant(Id typeId, unsigned long long value, bool specConstant); Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned value) const; Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned v1, unsigned v2) const; Id findCompositeConstant(Op typeClass, std::vector& comps) const; diff --git a/Test/baseResults/spv.int64.frag.out b/Test/baseResults/spv.int64.frag.out new file mode 100644 index 00000000..5088469e --- /dev/null +++ b/Test/baseResults/spv.int64.frag.out @@ -0,0 +1,629 @@ +spv.int64.frag +Warning, version 450 is not yet complete; most version-specific features are present, but some are missing. + + +Linked fragment stage: + + +Missing functionality: shader int64 +Missing functionality: shader int64 +Missing functionality: shader int64 +Missing functionality: shader int64 +// Module Version 10000 +// Generated by (magic number): 80001 +// Id's are bound by 455 + + Capability Shader + Capability Float64 + Capability Int64 + 1: ExtInstImport "GLSL.std.450" + MemoryModel Logical GLSL450 + EntryPoint Fragment 4 "main" + ExecutionMode 4 OriginUpperLeft + Source GLSL 450 + SourceExtension "GL_ARB_gpu_shader_int64" + Name 4 "main" + Name 6 "literal(" + Name 8 "typeCast(" + Name 10 "operators(" + Name 12 "builtinFuncs(" + Name 16 "i64" + Name 24 "Uniforms" + MemberName 24(Uniforms) 0 "index" + Name 26 "" + Name 33 "indexable" + Name 38 "u64" + Name 47 "indexable" + Name 52 "i64v" + Name 56 "bv" + Name 65 "u64v" + Name 74 "iv" + Name 81 "uv" + Name 89 "fv" + Name 95 "dv" + Name 132 "u64v" + Name 137 "i64" + Name 157 "i" + Name 164 "uv" + Name 216 "b" + Name 276 "i64v" + Name 279 "i64" + Name 289 "u64v" + Name 291 "u64" + Name 363 "dv" + Name 382 "iv" + Name 387 "uv" + Name 391 "bv" + Name 452 "Block" + MemberName 452(Block) 0 "i64v" + MemberName 452(Block) 1 "u64" + Name 454 "block" + MemberDecorate 24(Uniforms) 0 Offset 0 + Decorate 24(Uniforms) Block + Decorate 26 DescriptorSet 0 + Decorate 26 Binding 0 + MemberDecorate 452(Block) 0 Offset 0 + MemberDecorate 452(Block) 1 Offset 24 + Decorate 452(Block) Block + Decorate 454(block) DescriptorSet 0 + Decorate 454(block) Binding 1 + 2: TypeVoid + 3: TypeFunction 2 + 14: TypeInt 64 1 + 15: TypePointer Function 14(int) + 17: TypeInt 32 0 + 18: 17(int) Constant 3 + 19: TypeArray 14(int) 18 + 20: 14(int) Constant 4008636143 4008636142 + 21: 14(int) Constant 4294967295 4294967295 + 22: 14(int) Constant 0 1 + 23: 19 ConstantComposite 20 21 22 + 24(Uniforms): TypeStruct 17(int) + 25: TypePointer Uniform 24(Uniforms) + 26: 25(ptr) Variable Uniform + 27: TypeInt 32 1 + 28: 27(int) Constant 0 + 29: TypePointer Uniform 17(int) + 32: TypePointer Function 19 + 36: TypeInt 64 0 + 37: TypePointer Function 36(int) + 39: TypeArray 36(int) 18 + 40: 36(int) Constant 4294967295 4294967295 + 41: 36(int) Constant 0 1 + 42: 36(int) Constant 4294967295 1 + 43: 39 ConstantComposite 40 41 42 + 46: TypePointer Function 39 + 50: TypeVector 14(int) 2 + 51: TypePointer Function 50(ivec2) + 53: TypeBool + 54: TypeVector 53(bool) 2 + 55: TypePointer Function 54(bvec2) + 58: 14(int) Constant 0 0 + 59: 14(int) Constant 1 0 + 60: 50(ivec2) ConstantComposite 58 58 + 61: 50(ivec2) ConstantComposite 59 59 + 63: TypeVector 36(int) 2 + 64: TypePointer Function 63(ivec2) + 67: 36(int) Constant 0 0 + 68: 36(int) Constant 1 0 + 69: 63(ivec2) ConstantComposite 67 67 + 70: 63(ivec2) ConstantComposite 68 68 + 72: TypeVector 27(int) 2 + 73: TypePointer Function 72(ivec2) + 79: TypeVector 17(int) 2 + 80: TypePointer Function 79(ivec2) + 86: TypeFloat 32 + 87: TypeVector 86(float) 2 + 88: TypePointer Function 87(fvec2) + 92: TypeFloat 64 + 93: TypeVector 92(float) 2 + 94: TypePointer Function 93(fvec2) + 130: TypeVector 36(int) 3 + 131: TypePointer Function 130(ivec3) + 134: TypeVector 14(int) 3 + 156: TypePointer Function 27(int) + 162: TypeVector 17(int) 3 + 163: TypePointer Function 162(ivec3) + 197: TypeVector 27(int) 3 + 200: 17(int) Constant 1 + 201: TypePointer Function 17(int) + 207: 17(int) Constant 2 + 215: TypePointer Function 53(bool) + 217: 17(int) Constant 0 + 287: 50(ivec2) ConstantComposite 21 21 + 296: 130(ivec3) ConstantComposite 67 67 67 + 338: 53(bool) ConstantTrue + 345: 53(bool) ConstantFalse + 346: 54(bvec2) ConstantComposite 345 345 + 358: TypeVector 53(bool) 3 + 359: 358(bvec3) ConstantComposite 345 345 345 + 361: TypeVector 92(float) 3 + 362: TypePointer Function 361(fvec3) + 367: TypePointer Function 92(float) + 378: 27(int) Constant 1 + 379: 27(int) Constant 2 + 380: 72(ivec2) ConstantComposite 378 379 + 385: 79(ivec2) ConstantComposite 207 18 + 390: TypePointer Function 358(bvec3) + 452(Block): TypeStruct 134(ivec3) 36(int) + 453: TypePointer Uniform 452(Block) + 454(block): 453(ptr) Variable Uniform + 4(main): 2 Function None 3 + 5: Label + Return + FunctionEnd + 6(literal(): 2 Function None 3 + 7: Label + 16(i64): 15(ptr) Variable Function + 33(indexable): 32(ptr) Variable Function + 38(u64): 37(ptr) Variable Function + 47(indexable): 46(ptr) Variable Function + 30: 29(ptr) AccessChain 26 28 + 31: 17(int) Load 30 + Store 33(indexable) 23 + 34: 15(ptr) AccessChain 33(indexable) 31 + 35: 14(int) Load 34 + Store 16(i64) 35 + 44: 29(ptr) AccessChain 26 28 + 45: 17(int) Load 44 + Store 47(indexable) 43 + 48: 37(ptr) AccessChain 47(indexable) 45 + 49: 36(int) Load 48 + Store 38(u64) 49 + Return + FunctionEnd + 8(typeCast(): 2 Function None 3 + 9: Label + 52(i64v): 51(ptr) Variable Function + 56(bv): 55(ptr) Variable Function + 65(u64v): 64(ptr) Variable Function + 74(iv): 73(ptr) Variable Function + 81(uv): 80(ptr) Variable Function + 89(fv): 88(ptr) Variable Function + 95(dv): 94(ptr) Variable Function + 57: 54(bvec2) Load 56(bv) + 62: 50(ivec2) Select 57 61 60 + Store 52(i64v) 62 + 66: 54(bvec2) Load 56(bv) + 71: 63(ivec2) Select 66 70 69 + Store 65(u64v) 71 + 75: 72(ivec2) Load 74(iv) + 76: 50(ivec2) SConvert 75 + Store 52(i64v) 76 + 77: 50(ivec2) Load 52(i64v) + 78: 72(ivec2) SConvert 77 + Store 74(iv) 78 + 82: 79(ivec2) Load 81(uv) + 83: 63(ivec2) UConvert 82 + Store 65(u64v) 83 + 84: 63(ivec2) Load 65(u64v) + 85: 79(ivec2) UConvert 84 + Store 81(uv) 85 + 90: 50(ivec2) Load 52(i64v) + 91: 87(fvec2) ConvertSToF 90 + Store 89(fv) 91 + 96: 50(ivec2) Load 52(i64v) + 97: 93(fvec2) ConvertSToF 96 + Store 95(dv) 97 + 98: 63(ivec2) Load 65(u64v) + 99: 87(fvec2) ConvertUToF 98 + Store 89(fv) 99 + 100: 63(ivec2) Load 65(u64v) + 101: 93(fvec2) ConvertUToF 100 + Store 95(dv) 101 + 102: 87(fvec2) Load 89(fv) + 103: 50(ivec2) ConvertFToS 102 + Store 52(i64v) 103 + 104: 93(fvec2) Load 95(dv) + 105: 50(ivec2) ConvertFToS 104 + Store 52(i64v) 105 + 106: 87(fvec2) Load 89(fv) + 107: 63(ivec2) ConvertFToU 106 + Store 65(u64v) 107 + 108: 93(fvec2) Load 95(dv) + 109: 63(ivec2) ConvertFToU 108 + Store 65(u64v) 109 + 110: 50(ivec2) Load 52(i64v) + 111: 54(bvec2) INotEqual 110 69 + Store 56(bv) 111 + 112: 63(ivec2) Load 65(u64v) + 113: 54(bvec2) INotEqual 112 69 + Store 56(bv) 113 + 114: 50(ivec2) Load 52(i64v) + 115: 63(ivec2) Bitcast 114 + Store 65(u64v) 115 + 116: 63(ivec2) Load 65(u64v) + 117: 50(ivec2) Bitcast 116 + Store 52(i64v) 117 + 118: 50(ivec2) Load 52(i64v) + 119: 72(ivec2) SConvert 118 + 120: 79(ivec2) Bitcast 119 + Store 81(uv) 120 + 121: 79(ivec2) Load 81(uv) + 122: 63(ivec2) UConvert 121 + 123: 50(ivec2) Bitcast 122 + Store 52(i64v) 123 + 124: 63(ivec2) Load 65(u64v) + 125: 79(ivec2) UConvert 124 + 126: 72(ivec2) Bitcast 125 + Store 74(iv) 126 + 127: 72(ivec2) Load 74(iv) + 128: 50(ivec2) SConvert 127 + 129: 63(ivec2) Bitcast 128 + Store 65(u64v) 129 + Return + FunctionEnd + 10(operators(): 2 Function None 3 + 11: Label + 132(u64v): 131(ptr) Variable Function + 137(i64): 15(ptr) Variable Function + 157(i): 156(ptr) Variable Function + 164(uv): 163(ptr) Variable Function + 216(b): 215(ptr) Variable Function + 133: 130(ivec3) Load 132(u64v) + 135: 134(ivec3) CompositeConstruct 59 59 59 + 136: 130(ivec3) IAdd 133 135 + Store 132(u64v) 136 + 138: 14(int) Load 137(i64) + 139: 14(int) ISub 138 59 + Store 137(i64) 139 + 140: 14(int) Load 137(i64) + 141: 14(int) IAdd 140 59 + Store 137(i64) 141 + 142: 130(ivec3) Load 132(u64v) + 143: 134(ivec3) CompositeConstruct 59 59 59 + 144: 130(ivec3) ISub 142 143 + Store 132(u64v) 144 + 145: 130(ivec3) Load 132(u64v) + 146: 130(ivec3) Not 145 + Store 132(u64v) 146 + 147: 14(int) Load 137(i64) + Store 137(i64) 147 + 148: 130(ivec3) Load 132(u64v) + 149: 130(ivec3) SNegate 148 + Store 132(u64v) 149 + 150: 14(int) Load 137(i64) + 151: 14(int) Load 137(i64) + 152: 14(int) IAdd 151 150 + Store 137(i64) 152 + 153: 130(ivec3) Load 132(u64v) + 154: 130(ivec3) Load 132(u64v) + 155: 130(ivec3) ISub 154 153 + Store 132(u64v) 155 + 158: 27(int) Load 157(i) + 159: 14(int) SConvert 158 + 160: 14(int) Load 137(i64) + 161: 14(int) IMul 160 159 + Store 137(i64) 161 + 165: 162(ivec3) Load 164(uv) + 166: 130(ivec3) UConvert 165 + 167: 130(ivec3) Load 132(u64v) + 168: 130(ivec3) UDiv 167 166 + Store 132(u64v) 168 + 169: 27(int) Load 157(i) + 170: 14(int) SConvert 169 + 171: 36(int) Bitcast 170 + 172: 130(ivec3) Load 132(u64v) + 173: 130(ivec3) CompositeConstruct 171 171 171 + 174: 130(ivec3) UMod 172 173 + Store 132(u64v) 174 + 175: 130(ivec3) Load 132(u64v) + 176: 162(ivec3) Load 164(uv) + 177: 130(ivec3) UConvert 176 + 178: 130(ivec3) IAdd 175 177 + Store 132(u64v) 178 + 179: 14(int) Load 137(i64) + 180: 27(int) Load 157(i) + 181: 14(int) SConvert 180 + 182: 14(int) ISub 179 181 + Store 137(i64) 182 + 183: 130(ivec3) Load 132(u64v) + 184: 162(ivec3) Load 164(uv) + 185: 130(ivec3) UConvert 184 + 186: 130(ivec3) IMul 183 185 + Store 132(u64v) 186 + 187: 14(int) Load 137(i64) + 188: 27(int) Load 157(i) + 189: 14(int) SConvert 188 + 190: 14(int) IMul 187 189 + Store 137(i64) 190 + 191: 14(int) Load 137(i64) + 192: 27(int) Load 157(i) + 193: 14(int) SConvert 192 + 194: 14(int) SMod 191 193 + Store 137(i64) 194 + 195: 27(int) Load 157(i) + 196: 130(ivec3) Load 132(u64v) + 198: 197(ivec3) CompositeConstruct 195 195 195 + 199: 130(ivec3) ShiftLeftLogical 196 198 + Store 132(u64v) 199 + 202: 201(ptr) AccessChain 164(uv) 200 + 203: 17(int) Load 202 + 204: 14(int) Load 137(i64) + 205: 14(int) ShiftRightArithmetic 204 203 + Store 137(i64) 205 + 206: 14(int) Load 137(i64) + 208: 37(ptr) AccessChain 132(u64v) 207 + 209: 36(int) Load 208 + 210: 14(int) ShiftLeftLogical 206 209 + Store 137(i64) 210 + 211: 130(ivec3) Load 132(u64v) + 212: 14(int) Load 137(i64) + 213: 134(ivec3) CompositeConstruct 212 212 212 + 214: 130(ivec3) ShiftLeftLogical 211 213 + Store 132(u64v) 214 + 218: 37(ptr) AccessChain 132(u64v) 217 + 219: 36(int) Load 218 + 220: 14(int) Load 137(i64) + 221: 36(int) Bitcast 220 + 222: 53(bool) INotEqual 219 221 + Store 216(b) 222 + 223: 14(int) Load 137(i64) + 224: 36(int) Bitcast 223 + 225: 37(ptr) AccessChain 132(u64v) 217 + 226: 36(int) Load 225 + 227: 53(bool) IEqual 224 226 + Store 216(b) 227 + 228: 37(ptr) AccessChain 132(u64v) 217 + 229: 36(int) Load 228 + 230: 201(ptr) AccessChain 164(uv) 200 + 231: 17(int) Load 230 + 232: 36(int) UConvert 231 + 233: 53(bool) UGreaterThan 229 232 + Store 216(b) 233 + 234: 14(int) Load 137(i64) + 235: 27(int) Load 157(i) + 236: 14(int) SConvert 235 + 237: 53(bool) SLessThan 234 236 + Store 216(b) 237 + 238: 37(ptr) AccessChain 132(u64v) 200 + 239: 36(int) Load 238 + 240: 201(ptr) AccessChain 164(uv) 217 + 241: 17(int) Load 240 + 242: 36(int) UConvert 241 + 243: 53(bool) UGreaterThanEqual 239 242 + Store 216(b) 243 + 244: 14(int) Load 137(i64) + 245: 27(int) Load 157(i) + 246: 14(int) SConvert 245 + 247: 53(bool) SLessThanEqual 244 246 + Store 216(b) 247 + 248: 27(int) Load 157(i) + 249: 14(int) SConvert 248 + 250: 36(int) Bitcast 249 + 251: 130(ivec3) Load 132(u64v) + 252: 130(ivec3) CompositeConstruct 250 250 250 + 253: 130(ivec3) BitwiseOr 251 252 + Store 132(u64v) 253 + 254: 14(int) Load 137(i64) + 255: 27(int) Load 157(i) + 256: 14(int) SConvert 255 + 257: 14(int) BitwiseOr 254 256 + Store 137(i64) 257 + 258: 27(int) Load 157(i) + 259: 14(int) SConvert 258 + 260: 14(int) Load 137(i64) + 261: 14(int) BitwiseAnd 260 259 + Store 137(i64) 261 + 262: 130(ivec3) Load 132(u64v) + 263: 162(ivec3) Load 164(uv) + 264: 130(ivec3) UConvert 263 + 265: 130(ivec3) BitwiseAnd 262 264 + Store 132(u64v) 265 + 266: 14(int) Load 137(i64) + 267: 36(int) Bitcast 266 + 268: 130(ivec3) Load 132(u64v) + 269: 130(ivec3) CompositeConstruct 267 267 267 + 270: 130(ivec3) BitwiseXor 268 269 + Store 132(u64v) 270 + 271: 130(ivec3) Load 132(u64v) + 272: 14(int) Load 137(i64) + 273: 36(int) Bitcast 272 + 274: 130(ivec3) CompositeConstruct 273 273 273 + 275: 130(ivec3) BitwiseXor 271 274 + Store 132(u64v) 275 + Return + FunctionEnd +12(builtinFuncs(): 2 Function None 3 + 13: Label + 276(i64v): 51(ptr) Variable Function + 279(i64): 15(ptr) Variable Function + 289(u64v): 131(ptr) Variable Function + 291(u64): 37(ptr) Variable Function + 363(dv): 362(ptr) Variable Function + 382(iv): 73(ptr) Variable Function + 387(uv): 80(ptr) Variable Function + 391(bv): 390(ptr) Variable Function + 277: 50(ivec2) Load 276(i64v) + 278: 50(ivec2) ExtInst 1(GLSL.std.450) 5(SAbs) 277 + Store 276(i64v) 278 + 280: 14(int) Load 279(i64) + 281: 14(int) ExtInst 1(GLSL.std.450) 7(SSign) 280 + Store 279(i64) 281 + 282: 50(ivec2) Load 276(i64v) + 283: 14(int) Load 279(i64) + 284: 50(ivec2) CompositeConstruct 283 283 + 285: 50(ivec2) ExtInst 1(GLSL.std.450) 39(SMin) 282 284 + Store 276(i64v) 285 + 286: 50(ivec2) Load 276(i64v) + 288: 50(ivec2) ExtInst 1(GLSL.std.450) 39(SMin) 286 287 + Store 276(i64v) 288 + 290: 130(ivec3) Load 289(u64v) + 292: 36(int) Load 291(u64) + 293: 130(ivec3) CompositeConstruct 292 292 292 + 294: 130(ivec3) ExtInst 1(GLSL.std.450) 38(UMin) 290 293 + Store 289(u64v) 294 + 295: 130(ivec3) Load 289(u64v) + 297: 130(ivec3) ExtInst 1(GLSL.std.450) 38(UMin) 295 296 + Store 289(u64v) 297 + 298: 50(ivec2) Load 276(i64v) + 299: 14(int) Load 279(i64) + 300: 50(ivec2) CompositeConstruct 299 299 + 301: 50(ivec2) ExtInst 1(GLSL.std.450) 42(SMax) 298 300 + Store 276(i64v) 301 + 302: 50(ivec2) Load 276(i64v) + 303: 50(ivec2) ExtInst 1(GLSL.std.450) 42(SMax) 302 287 + Store 276(i64v) 303 + 304: 130(ivec3) Load 289(u64v) + 305: 36(int) Load 291(u64) + 306: 130(ivec3) CompositeConstruct 305 305 305 + 307: 130(ivec3) ExtInst 1(GLSL.std.450) 41(UMax) 304 306 + Store 289(u64v) 307 + 308: 130(ivec3) Load 289(u64v) + 309: 130(ivec3) ExtInst 1(GLSL.std.450) 41(UMax) 308 296 + Store 289(u64v) 309 + 310: 50(ivec2) Load 276(i64v) + 311: 14(int) Load 279(i64) + 312: 14(int) SNegate 311 + 313: 14(int) Load 279(i64) + 314: 50(ivec2) CompositeConstruct 312 312 + 315: 50(ivec2) CompositeConstruct 313 313 + 316: 50(ivec2) ExtInst 1(GLSL.std.450) 45(SClamp) 310 314 315 + Store 276(i64v) 316 + 317: 50(ivec2) Load 276(i64v) + 318: 50(ivec2) Load 276(i64v) + 319: 50(ivec2) SNegate 318 + 320: 50(ivec2) Load 276(i64v) + 321: 50(ivec2) ExtInst 1(GLSL.std.450) 45(SClamp) 317 319 320 + Store 276(i64v) 321 + 322: 130(ivec3) Load 289(u64v) + 323: 36(int) Load 291(u64) + 324: 36(int) SNegate 323 + 325: 36(int) Load 291(u64) + 326: 130(ivec3) CompositeConstruct 324 324 324 + 327: 130(ivec3) CompositeConstruct 325 325 325 + 328: 130(ivec3) ExtInst 1(GLSL.std.450) 44(UClamp) 322 326 327 + Store 289(u64v) 328 + 329: 130(ivec3) Load 289(u64v) + 330: 130(ivec3) Load 289(u64v) + 331: 130(ivec3) SNegate 330 + 332: 130(ivec3) Load 289(u64v) + 333: 130(ivec3) ExtInst 1(GLSL.std.450) 44(UClamp) 329 331 332 + Store 289(u64v) 333 + 334: 15(ptr) AccessChain 276(i64v) 217 + 335: 14(int) Load 334 + 336: 15(ptr) AccessChain 276(i64v) 200 + 337: 14(int) Load 336 + 339: 14(int) Select 338 337 335 + Store 279(i64) 339 + 340: 14(int) Load 279(i64) + 341: 50(ivec2) CompositeConstruct 340 340 + 342: 14(int) Load 279(i64) + 343: 14(int) SNegate 342 + 344: 50(ivec2) CompositeConstruct 343 343 + 347: 50(ivec2) Select 346 344 341 + Store 276(i64v) 347 + 348: 37(ptr) AccessChain 289(u64v) 217 + 349: 36(int) Load 348 + 350: 37(ptr) AccessChain 289(u64v) 200 + 351: 36(int) Load 350 + 352: 36(int) Select 338 351 349 + Store 291(u64) 352 + 353: 36(int) Load 291(u64) + 354: 130(ivec3) CompositeConstruct 353 353 353 + 355: 36(int) Load 291(u64) + 356: 36(int) SNegate 355 + 357: 130(ivec3) CompositeConstruct 356 356 356 + 360: 130(ivec3) Select 359 357 354 + Store 289(u64v) 360 + 364: 361(fvec3) Load 363(dv) + 365: 93(fvec2) VectorShuffle 364 364 0 1 + 366: 50(ivec2) Bitcast 365 + Store 276(i64v) 366 + 368: 367(ptr) AccessChain 363(dv) 207 + 369: 92(float) Load 368 + 370: 36(int) Bitcast 369 + 371: 37(ptr) AccessChain 289(u64v) 217 + Store 371 370 + 372: 50(ivec2) Load 276(i64v) + 373: 93(fvec2) Bitcast 372 + 374: 361(fvec3) Load 363(dv) + 375: 361(fvec3) VectorShuffle 374 373 3 4 2 + Store 363(dv) 375 + 376: 130(ivec3) Load 289(u64v) + 377: 361(fvec3) Bitcast 376 + Store 363(dv) 377 + 381: 14(int) ExtInst 1(GLSL.std.450) 0(Unknown) 380 + Store 279(i64) 381 + 383: 14(int) Load 279(i64) + 384: 72(ivec2) ExtInst 1(GLSL.std.450) 0(Unknown) 383 + Store 382(iv) 384 + 386: 36(int) ExtInst 1(GLSL.std.450) 0(Unknown) 385 + Store 291(u64) 386 + 388: 36(int) Load 291(u64) + 389: 79(ivec2) ExtInst 1(GLSL.std.450) 0(Unknown) 388 + Store 387(uv) 389 + 392: 130(ivec3) Load 289(u64v) + 393: 36(int) Load 291(u64) + 394: 130(ivec3) CompositeConstruct 393 393 393 + 395: 358(bvec3) ULessThan 392 394 + Store 391(bv) 395 + 396: 50(ivec2) Load 276(i64v) + 397: 14(int) Load 279(i64) + 398: 50(ivec2) CompositeConstruct 397 397 + 399: 54(bvec2) SLessThan 396 398 + 400: 358(bvec3) Load 391(bv) + 401: 358(bvec3) VectorShuffle 400 399 3 4 2 + Store 391(bv) 401 + 402: 130(ivec3) Load 289(u64v) + 403: 36(int) Load 291(u64) + 404: 130(ivec3) CompositeConstruct 403 403 403 + 405: 358(bvec3) ULessThanEqual 402 404 + Store 391(bv) 405 + 406: 50(ivec2) Load 276(i64v) + 407: 14(int) Load 279(i64) + 408: 50(ivec2) CompositeConstruct 407 407 + 409: 54(bvec2) SLessThanEqual 406 408 + 410: 358(bvec3) Load 391(bv) + 411: 358(bvec3) VectorShuffle 410 409 3 4 2 + Store 391(bv) 411 + 412: 130(ivec3) Load 289(u64v) + 413: 36(int) Load 291(u64) + 414: 130(ivec3) CompositeConstruct 413 413 413 + 415: 358(bvec3) UGreaterThan 412 414 + Store 391(bv) 415 + 416: 50(ivec2) Load 276(i64v) + 417: 14(int) Load 279(i64) + 418: 50(ivec2) CompositeConstruct 417 417 + 419: 54(bvec2) SGreaterThan 416 418 + 420: 358(bvec3) Load 391(bv) + 421: 358(bvec3) VectorShuffle 420 419 3 4 2 + Store 391(bv) 421 + 422: 130(ivec3) Load 289(u64v) + 423: 36(int) Load 291(u64) + 424: 130(ivec3) CompositeConstruct 423 423 423 + 425: 358(bvec3) UGreaterThanEqual 422 424 + Store 391(bv) 425 + 426: 50(ivec2) Load 276(i64v) + 427: 14(int) Load 279(i64) + 428: 50(ivec2) CompositeConstruct 427 427 + 429: 54(bvec2) SGreaterThanEqual 426 428 + 430: 358(bvec3) Load 391(bv) + 431: 358(bvec3) VectorShuffle 430 429 3 4 2 + Store 391(bv) 431 + 432: 130(ivec3) Load 289(u64v) + 433: 36(int) Load 291(u64) + 434: 130(ivec3) CompositeConstruct 433 433 433 + 435: 358(bvec3) IEqual 432 434 + Store 391(bv) 435 + 436: 50(ivec2) Load 276(i64v) + 437: 14(int) Load 279(i64) + 438: 50(ivec2) CompositeConstruct 437 437 + 439: 54(bvec2) IEqual 436 438 + 440: 358(bvec3) Load 391(bv) + 441: 358(bvec3) VectorShuffle 440 439 3 4 2 + Store 391(bv) 441 + 442: 130(ivec3) Load 289(u64v) + 443: 36(int) Load 291(u64) + 444: 130(ivec3) CompositeConstruct 443 443 443 + 445: 358(bvec3) INotEqual 442 444 + Store 391(bv) 445 + 446: 50(ivec2) Load 276(i64v) + 447: 14(int) Load 279(i64) + 448: 50(ivec2) CompositeConstruct 447 447 + 449: 54(bvec2) INotEqual 446 448 + 450: 358(bvec3) Load 391(bv) + 451: 358(bvec3) VectorShuffle 450 449 3 4 2 + Store 391(bv) 451 + Return + FunctionEnd diff --git a/Test/spv.int64.frag b/Test/spv.int64.frag new file mode 100644 index 00000000..527bfeff --- /dev/null +++ b/Test/spv.int64.frag @@ -0,0 +1,228 @@ +#version 450 + +#extension GL_ARB_gpu_shader_int64: enable + +layout(binding = 0) uniform Uniforms +{ + uint index; +}; + +layout(std140, binding = 1) uniform Block +{ + i64vec3 i64v; + uint64_t u64; +} block; + +void main() +{ +} + +void literal() +{ + const int64_t i64Const[3] = + { + -0x1111111111111111l, // Hex + -1l, // Dec + 040000000000l, // Oct + }; + + int64_t i64 = i64Const[index]; + + const uint64_t u64Const[] = + { + 0xFFFFFFFFFFFFFFFFul, // Hex + 4294967296UL, // Dec + 077777777777ul, // Oct + }; + + uint64_t u64 = u64Const[index]; +} + +void typeCast() +{ + bvec2 bv; + ivec2 iv; + uvec2 uv; + vec2 fv; + dvec2 dv; + + i64vec2 i64v; + u64vec2 u64v; + + i64v = i64vec2(bv); // bool -> int64 + u64v = u64vec2(bv); // bool -> uint64 + + i64v = iv; // int -> int64 + iv = ivec2(i64v); // int64 -> int + + u64v = uv; // uint -> uint64 + uv = uvec2(u64v); // uint64 -> uint + + fv = vec2(i64v); // int64 -> float + dv = i64v; // int64 -> double + + fv = vec2(u64v); // uint64 -> float + dv = u64v; // uint64 -> double + + i64v = i64vec2(fv); // float -> int64 + i64v = i64vec2(dv); // double -> int64 + + u64v = u64vec2(fv); // float -> uint64 + u64v = u64vec2(dv); // double -> uint64 + + bv = bvec2(i64v); // int64 -> bool + bv = bvec2(u64v); // uint64 -> bool + + u64v = i64v; // int64 -> uint64 + i64v = i64vec2(u64v); // uint64 -> int64 + + uv = uvec2(i64v); // int64 -> uint + i64v = i64vec2(uv); // uint -> int64 + iv = ivec2(u64v); // uint64 -> int + u64v = iv; // int -> uint64 +} + +void operators() +{ + u64vec3 u64v; + int64_t i64; + uvec3 uv; + int i; + bool b; + + // Unary + u64v++; + i64--; + ++i64; + --u64v; + + u64v = ~u64v; + + i64 = +i64; + u64v = -u64v; + + // Arithmetic + i64 += i64; + u64v -= u64v; + i64 *= i; + u64v /= uv; + u64v %= i; + + u64v = u64v + uv; + i64 = i64 - i; + u64v = u64v * uv; + i64 = i64 * i; + i64 = i64 % i; + + // Shift + u64v <<= i; + i64 >>= uv.y; + + i64 = i64 << u64v.z; + u64v = u64v << i64; + + // Relational + b = (u64v.x != i64); + b = (i64 == u64v.x); + b = (u64v.x > uv.y); + b = (i64 < i); + b = (u64v.y >= uv.x); + b = (i64 <= i); + + // Bitwise + u64v |= i; + i64 = i64 | i; + i64 &= i; + u64v = u64v & uv; + u64v ^= i64; + u64v = u64v ^ i64; +} + +void builtinFuncs() +{ + i64vec2 i64v; + u64vec3 u64v; + dvec3 dv; + bvec3 bv; + + int64_t i64; + uint64_t u64; + + // abs() + i64v = abs(i64v); + + // sign() + i64 = sign(i64); + + // min() + i64v = min(i64v, i64); + i64v = min(i64v, i64vec2(-1)); + u64v = min(u64v, u64); + u64v = min(u64v, u64vec3(0)); + + // max() + i64v = max(i64v, i64); + i64v = max(i64v, i64vec2(-1)); + u64v = max(u64v, u64); + u64v = max(u64v, u64vec3(0)); + + // clamp() + i64v = clamp(i64v, -i64, i64); + i64v = clamp(i64v, -i64v, i64v); + u64v = clamp(u64v, -u64, u64); + u64v = clamp(u64v, -u64v, u64v); + + // mix() + i64 = mix(i64v.x, i64v.y, true); + i64v = mix(i64vec2(i64), i64vec2(-i64), bvec2(false)); + u64 = mix(u64v.x, u64v.y, true); + u64v = mix(u64vec3(u64), u64vec3(-u64), bvec3(false)); + + // doubleBitsToInt64() + i64v = doubleBitsToInt64(dv.xy); + + // doubleBitsToUint64() + u64v.x = doubleBitsToUint64(dv.z); + + // int64BitsToDouble() + dv.xy = int64BitsToDouble(i64v); + + // uint64BitsToDouble() + dv = uint64BitsToDouble(u64v); + + // packInt2x32() + i64 = packInt2x32(ivec2(1, 2)); + + // unpackInt2x32() + ivec2 iv = unpackInt2x32(i64); + + // packUint2x32() + u64 = packUint2x32(uvec2(2, 3)); + + // unpackUint2x32() + uvec2 uv = unpackUint2x32(u64); + + // lessThan() + bv = lessThan(u64v, u64vec3(u64)); + bv.xy = lessThan(i64v, i64vec2(i64)); + + // lessThanEqual() + bv = lessThanEqual(u64v, u64vec3(u64)); + bv.xy = lessThanEqual(i64v, i64vec2(i64)); + + // greaterThan() + bv = greaterThan(u64v, u64vec3(u64)); + bv.xy = greaterThan(i64v, i64vec2(i64)); + + // greaterThanEqual() + bv = greaterThanEqual(u64v, u64vec3(u64)); + bv.xy = greaterThanEqual(i64v, i64vec2(i64)); + + // equal() + bv = equal(u64v, u64vec3(u64)); + bv.xy = equal(i64v, i64vec2(i64)); + + // notEqual() + bv = notEqual(u64v, u64vec3(u64)); + bv.xy = notEqual(i64v, i64vec2(i64)); +} \ No newline at end of file diff --git a/Test/test-spirv-list b/Test/test-spirv-list index b7dfd537..dfc6db7b 100644 --- a/Test/test-spirv-list +++ b/Test/test-spirv-list @@ -53,6 +53,7 @@ spv.forwardFun.frag spv.functionCall.frag spv.functionSemantics.frag spv.interpOps.frag +spv.int64.frag spv.layoutNested.vert spv.length.frag spv.localAggregates.frag diff --git a/glslang/Include/BaseTypes.h b/glslang/Include/BaseTypes.h index 5a57664f..ff4b560c 100644 --- a/glslang/Include/BaseTypes.h +++ b/glslang/Include/BaseTypes.h @@ -48,6 +48,8 @@ enum TBasicType { EbtDouble, EbtInt, EbtUint, + EbtInt64, + EbtUint64, EbtBool, EbtAtomicUint, EbtSampler, diff --git a/glslang/Include/ConstantUnion.h b/glslang/Include/ConstantUnion.h index c53870d9..8ee2c84c 100644 --- a/glslang/Include/ConstantUnion.h +++ b/glslang/Include/ConstantUnion.h @@ -57,6 +57,18 @@ public: type = EbtUint; } + void setI64Const(long long i64) + { + i64Const = i64; + type = EbtInt64; + } + + void setU64Const(unsigned long long u64) + { + u64Const = u64; + type = EbtUint64; + } + void setDConst(double d) { dConst = d; @@ -69,10 +81,12 @@ public: type = EbtBool; } - int getIConst() const { return iConst; } - unsigned int getUConst() const { return uConst; } - double getDConst() const { return dConst; } - bool getBConst() const { return bConst; } + int getIConst() const { return iConst; } + unsigned int getUConst() const { return uConst; } + long long getI64Const() const { return i64Const; } + unsigned long long getU64Const() const { return u64Const; } + double getDConst() const { return dConst; } + bool getBConst() const { return bConst; } bool operator==(const int i) const { @@ -82,7 +96,7 @@ public: return false; } - bool operator==(unsigned const int u) const + bool operator==(const unsigned int u) const { if (u == uConst) return true; @@ -90,6 +104,22 @@ public: return false; } + bool operator==(const long long i64) const + { + if (i64 == i64Const) + return true; + + return false; + } + + bool operator==(const unsigned long long u64) const + { + if (u64 == u64Const) + return true; + + return false; + } + bool operator==(const double d) const { if (d == dConst) @@ -121,6 +151,16 @@ public: if (constant.uConst == uConst) return true; + break; + case EbtInt64: + if (constant.i64Const == i64Const) + return true; + + break; + case EbtUint64: + if (constant.u64Const == u64Const) + return true; + break; case EbtDouble: if (constant.dConst == dConst) @@ -149,6 +189,16 @@ public: return !operator==(u); } + bool operator!=(const long long i) const + { + return !operator==(i); + } + + bool operator!=(const unsigned long long u) const + { + return !operator==(u); + } + bool operator!=(const float f) const { return !operator==(f); @@ -177,6 +227,16 @@ public: if (uConst > constant.uConst) return true; + return false; + case EbtInt64: + if (i64Const > constant.i64Const) + return true; + + return false; + case EbtUint64: + if (u64Const > constant.u64Const) + return true; + return false; case EbtDouble: if (dConst > constant.dConst) @@ -202,6 +262,16 @@ public: if (uConst < constant.uConst) return true; + return false; + case EbtInt64: + if (i64Const < constant.i64Const) + return true; + + return false; + case EbtUint64: + if (u64Const < constant.u64Const) + return true; + return false; case EbtDouble: if (dConst < constant.dConst) @@ -220,7 +290,9 @@ public: assert(type == constant.type); switch (type) { case EbtInt: returnValue.setIConst(iConst + constant.iConst); break; + case EbtInt64: returnValue.setI64Const(i64Const + constant.i64Const); break; case EbtUint: returnValue.setUConst(uConst + constant.uConst); break; + case EbtUint64: returnValue.setU64Const(u64Const + constant.u64Const); break; case EbtDouble: returnValue.setDConst(dConst + constant.dConst); break; default: assert(false && "Default missing"); } @@ -234,7 +306,9 @@ public: assert(type == constant.type); switch (type) { case EbtInt: returnValue.setIConst(iConst - constant.iConst); break; + case EbtInt64: returnValue.setI64Const(i64Const - constant.i64Const); break; case EbtUint: returnValue.setUConst(uConst - constant.uConst); break; + case EbtUint64: returnValue.setU64Const(u64Const - constant.u64Const); break; case EbtDouble: returnValue.setDConst(dConst - constant.dConst); break; default: assert(false && "Default missing"); } @@ -248,7 +322,9 @@ public: assert(type == constant.type); switch (type) { case EbtInt: returnValue.setIConst(iConst * constant.iConst); break; + case EbtInt64: returnValue.setI64Const(i64Const * constant.i64Const); break; case EbtUint: returnValue.setUConst(uConst * constant.uConst); break; + case EbtUint64: returnValue.setU64Const(u64Const * constant.u64Const); break; case EbtDouble: returnValue.setDConst(dConst * constant.dConst); break; default: assert(false && "Default missing"); } @@ -261,8 +337,10 @@ public: TConstUnion returnValue; assert(type == constant.type); switch (type) { - case EbtInt: returnValue.setIConst(iConst % constant.iConst); break; + case EbtInt: returnValue.setIConst(iConst % constant.iConst); break; + case EbtInt64: returnValue.setI64Const(i64Const % constant.i64Const); break; case EbtUint: returnValue.setUConst(uConst % constant.uConst); break; + case EbtUint64: returnValue.setU64Const(u64Const % constant.u64Const); break; default: assert(false && "Default missing"); } @@ -275,16 +353,38 @@ public: switch (type) { case EbtInt: switch (constant.type) { - case EbtInt: returnValue.setIConst(iConst >> constant.iConst); break; - case EbtUint: returnValue.setIConst(iConst >> constant.uConst); break; - default: assert(false && "Default missing"); + case EbtInt: returnValue.setIConst(iConst >> constant.iConst); break; + case EbtUint: returnValue.setIConst(iConst >> constant.uConst); break; + case EbtInt64: returnValue.setIConst(iConst >> constant.i64Const); break; + case EbtUint64: returnValue.setIConst(iConst >> constant.u64Const); break; + default: assert(false && "Default missing"); } break; case EbtUint: switch (constant.type) { - case EbtInt: returnValue.setUConst(uConst >> constant.iConst); break; - case EbtUint: returnValue.setUConst(uConst >> constant.uConst); break; - default: assert(false && "Default missing"); + case EbtInt: returnValue.setUConst(uConst >> constant.iConst); break; + case EbtUint: returnValue.setUConst(uConst >> constant.uConst); break; + case EbtInt64: returnValue.setUConst(uConst >> constant.i64Const); break; + case EbtUint64: returnValue.setUConst(uConst >> constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; + case EbtInt64: + switch (constant.type) { + case EbtInt: returnValue.setI64Const(i64Const >> constant.iConst); break; + case EbtUint: returnValue.setI64Const(i64Const >> constant.uConst); break; + case EbtInt64: returnValue.setI64Const(i64Const >> constant.i64Const); break; + case EbtUint64: returnValue.setI64Const(i64Const >> constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; + case EbtUint64: + switch (constant.type) { + case EbtInt: returnValue.setU64Const(u64Const >> constant.iConst); break; + case EbtUint: returnValue.setU64Const(u64Const >> constant.uConst); break; + case EbtInt64: returnValue.setU64Const(u64Const >> constant.i64Const); break; + case EbtUint64: returnValue.setU64Const(u64Const >> constant.u64Const); break; + default: assert(false && "Default missing"); } break; default: assert(false && "Default missing"); @@ -299,16 +399,38 @@ public: switch (type) { case EbtInt: switch (constant.type) { - case EbtInt: returnValue.setIConst(iConst << constant.iConst); break; - case EbtUint: returnValue.setIConst(iConst << constant.uConst); break; - default: assert(false && "Default missing"); + case EbtInt: returnValue.setIConst(iConst << constant.iConst); break; + case EbtUint: returnValue.setIConst(iConst << constant.uConst); break; + case EbtInt64: returnValue.setIConst(iConst << constant.i64Const); break; + case EbtUint64: returnValue.setIConst(iConst << constant.u64Const); break; + default: assert(false && "Default missing"); } break; case EbtUint: switch (constant.type) { - case EbtInt: returnValue.setUConst(uConst << constant.iConst); break; - case EbtUint: returnValue.setUConst(uConst << constant.uConst); break; - default: assert(false && "Default missing"); + case EbtInt: returnValue.setUConst(uConst << constant.iConst); break; + case EbtUint: returnValue.setUConst(uConst << constant.uConst); break; + case EbtInt64: returnValue.setUConst(uConst << constant.i64Const); break; + case EbtUint64: returnValue.setUConst(uConst << constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; + case EbtInt64: + switch (constant.type) { + case EbtInt: returnValue.setI64Const(i64Const << constant.iConst); break; + case EbtUint: returnValue.setI64Const(i64Const << constant.uConst); break; + case EbtInt64: returnValue.setI64Const(i64Const << constant.i64Const); break; + case EbtUint64: returnValue.setI64Const(i64Const << constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; + case EbtUint64: + switch (constant.type) { + case EbtInt: returnValue.setU64Const(u64Const << constant.iConst); break; + case EbtUint: returnValue.setU64Const(u64Const << constant.uConst); break; + case EbtInt64: returnValue.setU64Const(u64Const << constant.i64Const); break; + case EbtUint64: returnValue.setU64Const(u64Const << constant.u64Const); break; + default: assert(false && "Default missing"); } break; default: assert(false && "Default missing"); @@ -324,6 +446,8 @@ public: switch (type) { case EbtInt: returnValue.setIConst(iConst & constant.iConst); break; case EbtUint: returnValue.setUConst(uConst & constant.uConst); break; + case EbtInt64: returnValue.setI64Const(i64Const & constant.i64Const); break; + case EbtUint64: returnValue.setU64Const(u64Const & constant.u64Const); break; default: assert(false && "Default missing"); } @@ -337,6 +461,8 @@ public: switch (type) { case EbtInt: returnValue.setIConst(iConst | constant.iConst); break; case EbtUint: returnValue.setUConst(uConst | constant.uConst); break; + case EbtInt64: returnValue.setI64Const(i64Const | constant.i64Const); break; + case EbtUint64: returnValue.setU64Const(u64Const | constant.u64Const); break; default: assert(false && "Default missing"); } @@ -350,6 +476,8 @@ public: switch (type) { case EbtInt: returnValue.setIConst(iConst ^ constant.iConst); break; case EbtUint: returnValue.setUConst(uConst ^ constant.uConst); break; + case EbtInt64: returnValue.setI64Const(i64Const ^ constant.i64Const); break; + case EbtUint64: returnValue.setU64Const(u64Const ^ constant.u64Const); break; default: assert(false && "Default missing"); } @@ -362,6 +490,8 @@ public: switch (type) { case EbtInt: returnValue.setIConst(~iConst); break; case EbtUint: returnValue.setUConst(~uConst); break; + case EbtInt64: returnValue.setI64Const(~i64Const); break; + case EbtUint64: returnValue.setU64Const(~u64Const); break; default: assert(false && "Default missing"); } @@ -396,10 +526,12 @@ public: private: union { - int iConst; // used for ivec, scalar ints - unsigned int uConst; // used for uvec, scalar uints - bool bConst; // used for bvec, scalar bools - double dConst; // used for vec, dvec, mat, dmat, scalar floats and doubles + int iConst; // used for ivec, scalar ints + unsigned int uConst; // used for uvec, scalar uints + long long i64Const; // used for i64vec, scalar int64s + unsigned long long u64Const; // used for u64vec, scalar uint64s + bool bConst; // used for bvec, scalar bools + double dConst; // used for vec, dvec, mat, dmat, scalar floats and doubles }; TBasicType type; diff --git a/glslang/Include/Types.h b/glslang/Include/Types.h index e28e5b29..38a27d4e 100644 --- a/glslang/Include/Types.h +++ b/glslang/Include/Types.h @@ -182,6 +182,8 @@ 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) { @@ -1319,6 +1321,8 @@ public: case EbtDouble: case EbtInt: case EbtUint: + case EbtInt64: + case EbtUint64: case EbtBool: return true; default: @@ -1409,6 +1413,8 @@ public: case EbtDouble: return "double"; case EbtInt: return "int"; case EbtUint: return "uint"; + case EbtInt64: return "int64_t"; + case EbtUint64: return "uint64_t"; 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 ab177011..1dd55a7b 100644 --- a/glslang/Include/intermediate.h +++ b/glslang/Include/intermediate.h @@ -81,22 +81,44 @@ enum TOperator { EOpConvUintToBool, EOpConvFloatToBool, EOpConvDoubleToBool, + EOpConvInt64ToBool, + EOpConvUint64ToBool, EOpConvBoolToFloat, EOpConvIntToFloat, EOpConvUintToFloat, EOpConvDoubleToFloat, + EOpConvInt64ToFloat, + EOpConvUint64ToFloat, EOpConvUintToInt, EOpConvFloatToInt, EOpConvBoolToInt, EOpConvDoubleToInt, + EOpConvInt64ToInt, + EOpConvUint64ToInt, EOpConvIntToUint, EOpConvFloatToUint, EOpConvBoolToUint, EOpConvDoubleToUint, + EOpConvInt64ToUint, + EOpConvUint64ToUint, EOpConvIntToDouble, EOpConvUintToDouble, EOpConvFloatToDouble, EOpConvBoolToDouble, + EOpConvInt64ToDouble, + EOpConvUint64ToDouble, + EOpConvBoolToInt64, + EOpConvIntToInt64, + EOpConvUintToInt64, + EOpConvFloatToInt64, + EOpConvDoubleToInt64, + EOpConvUint64ToInt64, + EOpConvBoolToUint64, + EOpConvIntToUint64, + EOpConvUintToUint64, + EOpConvFloatToUint64, + EOpConvDoubleToUint64, + EOpConvInt64ToUint64, // // binary operations @@ -194,6 +216,10 @@ enum TOperator { EOpFloatBitsToUint, EOpIntBitsToFloat, EOpUintBitsToFloat, + EOpDoubleBitsToInt64, + EOpDoubleBitsToUint64, + EOpInt64BitsToDouble, + EOpUint64BitsToDouble, EOpPackSnorm2x16, EOpUnpackSnorm2x16, EOpPackUnorm2x16, @@ -206,6 +232,10 @@ enum TOperator { EOpUnpackHalf2x16, EOpPackDouble2x32, EOpUnpackDouble2x32, + EOpPackInt2x32, + EOpUnpackInt2x32, + EOpPackUint2x32, + EOpUnpackUint2x32, EOpLength, EOpDistance, @@ -287,6 +317,8 @@ enum TOperator { EOpConstructGuardStart, EOpConstructInt, // these first scalar forms also identify what implicit conversion is needed EOpConstructUint, + EOpConstructInt64, + EOpConstructUint64, EOpConstructBool, EOpConstructFloat, EOpConstructDouble, @@ -305,6 +337,12 @@ enum TOperator { EOpConstructUVec2, EOpConstructUVec3, EOpConstructUVec4, + EOpConstructI64Vec2, + EOpConstructI64Vec3, + EOpConstructI64Vec4, + EOpConstructU64Vec2, + EOpConstructU64Vec3, + EOpConstructU64Vec4, EOpConstructMat2x2, EOpConstructMat2x3, EOpConstructMat2x4, diff --git a/glslang/MachineIndependent/Constant.cpp b/glslang/MachineIndependent/Constant.cpp index db2f70da..03033bce 100644 --- a/glslang/MachineIndependent/Constant.cpp +++ b/glslang/MachineIndependent/Constant.cpp @@ -194,6 +194,22 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TIntermTyped* right } else newConstArray[i].setUConst(leftUnionArray[i].getUConst() / rightUnionArray[i].getUConst()); break; + + case EbtInt64: + if (rightUnionArray[i] == 0) + newConstArray[i].setI64Const(0x7FFFFFFFFFFFFFFFll); + else if (rightUnionArray[i].getI64Const() == -1 && leftUnionArray[i].getI64Const() == (long long)0x8000000000000000) + newConstArray[i].setI64Const(0x8000000000000000); + else + newConstArray[i].setI64Const(leftUnionArray[i].getI64Const() / rightUnionArray[i].getI64Const()); + break; + + case EbtUint64: + if (rightUnionArray[i] == 0) { + newConstArray[i].setU64Const(0xFFFFFFFFFFFFFFFFull); + } else + newConstArray[i].setU64Const(leftUnionArray[i].getU64Const() / rightUnionArray[i].getU64Const()); + break; default: return 0; } @@ -419,6 +435,8 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType) case EbtFloat: newConstArray[i].setDConst(-unionArray[i].getDConst()); break; case EbtInt: newConstArray[i].setIConst(-unionArray[i].getIConst()); break; 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; default: return 0; } @@ -566,6 +584,8 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType) case EOpFloatBitsToUint: case EOpIntBitsToFloat: case EOpUintBitsToFloat: + case EOpDoubleBitsToInt64: + case EOpDoubleBitsToUint64: default: return 0; @@ -651,7 +671,10 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode) bool isFloatingPoint = children[0]->getAsTyped()->getBasicType() == EbtFloat || children[0]->getAsTyped()->getBasicType() == EbtDouble; - bool isSigned = children[0]->getAsTyped()->getBasicType() == EbtInt; + bool isSigned = children[0]->getAsTyped()->getBasicType() == EbtInt || + children[0]->getAsTyped()->getBasicType() == EbtInt64; + bool isInt64 = children[0]->getAsTyped()->getBasicType() == EbtInt64 || + children[0]->getAsTyped()->getBasicType() == EbtUint64; if (componentwise) { for (int comp = 0; comp < objectSize; comp++) { @@ -674,29 +697,52 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode) case EOpMin: if (isFloatingPoint) newConstArray[comp].setDConst(std::min(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst())); - else if (isSigned) - newConstArray[comp].setIConst(std::min(childConstUnions[0][arg0comp].getIConst(), childConstUnions[1][arg1comp].getIConst())); - else - newConstArray[comp].setUConst(std::min(childConstUnions[0][arg0comp].getUConst(), childConstUnions[1][arg1comp].getUConst())); + else if (isSigned) { + if (isInt64) + newConstArray[comp].setI64Const(std::min(childConstUnions[0][arg0comp].getI64Const(), childConstUnions[1][arg1comp].getI64Const())); + else + newConstArray[comp].setIConst(std::min(childConstUnions[0][arg0comp].getIConst(), childConstUnions[1][arg1comp].getIConst())); + } else { + if (isInt64) + newConstArray[comp].setU64Const(std::min(childConstUnions[0][arg0comp].getU64Const(), childConstUnions[1][arg1comp].getU64Const())); + else + newConstArray[comp].setUConst(std::min(childConstUnions[0][arg0comp].getUConst(), childConstUnions[1][arg1comp].getUConst())); + } break; case EOpMax: if (isFloatingPoint) newConstArray[comp].setDConst(std::max(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst())); - else if (isSigned) - newConstArray[comp].setIConst(std::max(childConstUnions[0][arg0comp].getIConst(), childConstUnions[1][arg1comp].getIConst())); - else - newConstArray[comp].setUConst(std::max(childConstUnions[0][arg0comp].getUConst(), childConstUnions[1][arg1comp].getUConst())); + else if (isSigned) { + if (isInt64) + newConstArray[comp].setI64Const(std::max(childConstUnions[0][arg0comp].getI64Const(), childConstUnions[1][arg1comp].getI64Const())); + else + newConstArray[comp].setIConst(std::max(childConstUnions[0][arg0comp].getIConst(), childConstUnions[1][arg1comp].getIConst())); + } else { + if (isInt64) + newConstArray[comp].setU64Const(std::max(childConstUnions[0][arg0comp].getU64Const(), childConstUnions[1][arg1comp].getU64Const())); + else + newConstArray[comp].setUConst(std::max(childConstUnions[0][arg0comp].getUConst(), childConstUnions[1][arg1comp].getUConst())); + } break; case EOpClamp: if (isFloatingPoint) - newConstArray[comp].setDConst(std::min(std::max(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst()), + newConstArray[comp].setDConst(std::min(std::max(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst()), childConstUnions[2][arg2comp].getDConst())); - else if (isSigned) - newConstArray[comp].setIConst(std::min(std::max(childConstUnions[0][arg0comp].getIConst(), childConstUnions[1][arg1comp].getIConst()), - childConstUnions[2][arg2comp].getIConst())); - else - newConstArray[comp].setUConst(std::min(std::max(childConstUnions[0][arg0comp].getUConst(), childConstUnions[1][arg1comp].getUConst()), - childConstUnions[2][arg2comp].getUConst())); + else if (isSigned) { + if (isInt64) + newConstArray[comp].setI64Const(std::min(std::max(childConstUnions[0][arg0comp].getI64Const(), childConstUnions[1][arg1comp].getI64Const()), + childConstUnions[2][arg2comp].getI64Const())); + else + newConstArray[comp].setIConst(std::min(std::max(childConstUnions[0][arg0comp].getIConst(), childConstUnions[1][arg1comp].getIConst()), + childConstUnions[2][arg2comp].getIConst())); + } else { + if (isInt64) + newConstArray[comp].setU64Const(std::min(std::max(childConstUnions[0][arg0comp].getU64Const(), childConstUnions[1][arg1comp].getU64Const()), + childConstUnions[2][arg2comp].getU64Const())); + else + newConstArray[comp].setUConst(std::min(std::max(childConstUnions[0][arg0comp].getUConst(), childConstUnions[1][arg1comp].getUConst()), + childConstUnions[2][arg2comp].getUConst())); + } break; case EOpLessThan: newConstArray[comp].setBConst(childConstUnions[0][arg0comp] < childConstUnions[1][arg1comp]); diff --git a/glslang/MachineIndependent/Initialize.cpp b/glslang/MachineIndependent/Initialize.cpp index 446c51c9..e2bd4531 100644 --- a/glslang/MachineIndependent/Initialize.cpp +++ b/glslang/MachineIndependent/Initialize.cpp @@ -75,6 +75,8 @@ 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"; @@ -626,6 +628,145 @@ void TBuiltIns::initialize(int version, EProfile profile, int spv, int vulkan) "dmat2 inverse(dmat2);" "dmat3 inverse(dmat3);" "dmat4 inverse(dmat4);" + + "\n"); + } + + if (profile != EEsProfile && version >= 450) { + commonBuiltins.append( + + "int64_t abs(int64_t);" + "i64vec2 abs(i64vec2);" + "i64vec3 abs(i64vec3);" + "i64vec4 abs(i64vec4);" + + "int64_t sign(int64_t);" + "i64vec2 sign(i64vec2);" + "i64vec3 sign(i64vec3);" + "i64vec4 sign(i64vec4);" + + "int64_t min(int64_t, int64_t);" + "i64vec2 min(i64vec2, int64_t);" + "i64vec3 min(i64vec3, int64_t);" + "i64vec4 min(i64vec4, int64_t);" + "i64vec2 min(i64vec2, i64vec2);" + "i64vec3 min(i64vec3, i64vec3);" + "i64vec4 min(i64vec4, i64vec4);" + "uint64_t min(uint64_t, uint64_t);" + "u64vec2 min(u64vec2, uint64_t);" + "u64vec3 min(u64vec3, uint64_t);" + "u64vec4 min(u64vec4, uint64_t);" + "u64vec2 min(u64vec2, u64vec2);" + "u64vec3 min(u64vec3, u64vec3);" + "u64vec4 min(u64vec4, u64vec4);" + + "int64_t max(int64_t, int64_t);" + "i64vec2 max(i64vec2, int64_t);" + "i64vec3 max(i64vec3, int64_t);" + "i64vec4 max(i64vec4, int64_t);" + "i64vec2 max(i64vec2, i64vec2);" + "i64vec3 max(i64vec3, i64vec3);" + "i64vec4 max(i64vec4, i64vec4);" + "uint64_t max(uint64_t, uint64_t);" + "u64vec2 max(u64vec2, uint64_t);" + "u64vec3 max(u64vec3, uint64_t);" + "u64vec4 max(u64vec4, uint64_t);" + "u64vec2 max(u64vec2, u64vec2);" + "u64vec3 max(u64vec3, u64vec3);" + "u64vec4 max(u64vec4, u64vec4);" + + "int64_t clamp(int64_t, int64_t, int64_t);" + "i64vec2 clamp(i64vec2, int64_t, int64_t);" + "i64vec3 clamp(i64vec3, int64_t, int64_t);" + "i64vec4 clamp(i64vec4, int64_t, int64_t);" + "i64vec2 clamp(i64vec2, i64vec2, i64vec2);" + "i64vec3 clamp(i64vec3, i64vec3, i64vec3);" + "i64vec4 clamp(i64vec4, i64vec4, i64vec4);" + "uint64_t clamp(uint64_t, uint64_t, uint64_t);" + "u64vec2 clamp(u64vec2, uint64_t, uint64_t);" + "u64vec3 clamp(u64vec3, uint64_t, uint64_t);" + "u64vec4 clamp(u64vec4, uint64_t, uint64_t);" + "u64vec2 clamp(u64vec2, u64vec2, u64vec2);" + "u64vec3 clamp(u64vec3, u64vec3, u64vec3);" + "u64vec4 clamp(u64vec4, u64vec4, u64vec4);" + + "int64_t mix(int64_t, int64_t, bool);" + "i64vec2 mix(i64vec2, i64vec2, bvec2);" + "i64vec3 mix(i64vec3, i64vec3, bvec3);" + "i64vec4 mix(i64vec4, i64vec4, bvec4);" + "uint64_t mix(uint64_t, uint64_t, bool);" + "u64vec2 mix(u64vec2, u64vec2, bvec2);" + "u64vec3 mix(u64vec3, u64vec3, bvec3);" + "u64vec4 mix(u64vec4, u64vec4, bvec4);" + + "int64_t doubleBitsToInt64(double);" + "i64vec2 doubleBitsToInt64(dvec2);" + "i64vec3 doubleBitsToInt64(dvec3);" + "i64vec4 doubleBitsToInt64(dvec4);" + + "uint64_t doubleBitsToUint64(double);" + "u64vec2 doubleBitsToUint64(dvec2);" + "u64vec3 doubleBitsToUint64(dvec3);" + "u64vec4 doubleBitsToUint64(dvec4);" + + "double int64BitsToDouble(int64_t);" + "dvec2 int64BitsToDouble(i64vec2);" + "dvec3 int64BitsToDouble(i64vec3);" + "dvec4 int64BitsToDouble(i64vec4);" + + "double uint64BitsToDouble(uint64_t);" + "dvec2 uint64BitsToDouble(u64vec2);" + "dvec3 uint64BitsToDouble(u64vec3);" + "dvec4 uint64BitsToDouble(u64vec4);" + + "int64_t packInt2x32(ivec2);" + "uint64_t packUint2x32(uvec2);" + "ivec2 unpackInt2x32(int64_t);" + "uvec2 unpackUint2x32(uint64_t);" + + "bvec2 lessThan(i64vec2, i64vec2);" + "bvec3 lessThan(i64vec3, i64vec3);" + "bvec4 lessThan(i64vec4, i64vec4);" + "bvec2 lessThan(u64vec2, u64vec2);" + "bvec3 lessThan(u64vec3, u64vec3);" + "bvec4 lessThan(u64vec4, u64vec4);" + + "bvec2 lessThanEqual(i64vec2, i64vec2);" + "bvec3 lessThanEqual(i64vec3, i64vec3);" + "bvec4 lessThanEqual(i64vec4, i64vec4);" + "bvec2 lessThanEqual(u64vec2, u64vec2);" + "bvec3 lessThanEqual(u64vec3, u64vec3);" + "bvec4 lessThanEqual(u64vec4, u64vec4);" + + "bvec2 greaterThan(i64vec2, i64vec2);" + "bvec3 greaterThan(i64vec3, i64vec3);" + "bvec4 greaterThan(i64vec4, i64vec4);" + "bvec2 greaterThan(u64vec2, u64vec2);" + "bvec3 greaterThan(u64vec3, u64vec3);" + "bvec4 greaterThan(u64vec4, u64vec4);" + + "bvec2 greaterThanEqual(i64vec2, i64vec2);" + "bvec3 greaterThanEqual(i64vec3, i64vec3);" + "bvec4 greaterThanEqual(i64vec4, i64vec4);" + "bvec2 greaterThanEqual(u64vec2, u64vec2);" + "bvec3 greaterThanEqual(u64vec3, u64vec3);" + "bvec4 greaterThanEqual(u64vec4, u64vec4);" + + "bvec2 equal(i64vec2, i64vec2);" + "bvec3 equal(i64vec3, i64vec3);" + "bvec4 equal(i64vec4, i64vec4);" + "bvec2 equal(u64vec2, u64vec2);" + "bvec3 equal(u64vec3, u64vec3);" + "bvec4 equal(u64vec4, u64vec4);" + + "bvec2 notEqual(i64vec2, i64vec2);" + "bvec3 notEqual(i64vec3, i64vec3);" + "bvec4 notEqual(i64vec4, i64vec4);" + "bvec2 notEqual(u64vec2, u64vec2);" + "bvec3 notEqual(u64vec3, u64vec3);" + "bvec4 notEqual(u64vec4, u64vec4);" + + "\n" ); } @@ -3650,6 +3791,10 @@ void IdentifyBuiltIns(int version, EProfile profile, int spv, int vulkan, EShLan symbolTable.relateToOperator("floatBitsToUint", EOpFloatBitsToUint); symbolTable.relateToOperator("intBitsToFloat", EOpIntBitsToFloat); symbolTable.relateToOperator("uintBitsToFloat", EOpUintBitsToFloat); + symbolTable.relateToOperator("doubleBitsToInt64", EOpDoubleBitsToInt64); + symbolTable.relateToOperator("doubleBitsToUint64", EOpDoubleBitsToUint64); + symbolTable.relateToOperator("int64BitsToDouble", EOpInt64BitsToDouble); + symbolTable.relateToOperator("uint64BitsToDouble", EOpUint64BitsToDouble); symbolTable.relateToOperator("packSnorm2x16", EOpPackSnorm2x16); symbolTable.relateToOperator("unpackSnorm2x16", EOpUnpackSnorm2x16); @@ -3667,6 +3812,11 @@ void IdentifyBuiltIns(int version, EProfile profile, int spv, int vulkan, EShLan symbolTable.relateToOperator("packHalf2x16", EOpPackHalf2x16); symbolTable.relateToOperator("unpackHalf2x16", EOpUnpackHalf2x16); + symbolTable.relateToOperator("packInt2x32", EOpPackInt2x32); + symbolTable.relateToOperator("unpackInt2x32", EOpUnpackInt2x32); + symbolTable.relateToOperator("packUint2x32", EOpPackUint2x32); + symbolTable.relateToOperator("unpackUint2x32", EOpUnpackUint2x32); + symbolTable.relateToOperator("length", EOpLength); symbolTable.relateToOperator("distance", EOpDistance); symbolTable.relateToOperator("dot", EOpDot); diff --git a/glslang/MachineIndependent/Intermediate.cpp b/glslang/MachineIndependent/Intermediate.cpp index d0fa74e5..47a93670 100644 --- a/glslang/MachineIndependent/Intermediate.cpp +++ b/glslang/MachineIndependent/Intermediate.cpp @@ -247,6 +247,8 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child, TSo switch (op) { case EOpConstructInt: newType = EbtInt; break; case EOpConstructUint: newType = EbtUint; break; + case EOpConstructInt64: newType = EbtInt64; break; + case EOpConstructUint64: newType = EbtUint64; break; case EOpConstructBool: newType = EbtBool; break; case EOpConstructFloat: newType = EbtFloat; break; case EOpConstructDouble: newType = EbtDouble; break; @@ -269,6 +271,8 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child, TSo switch (op) { case EOpConstructInt: case EOpConstructUint: + case EOpConstructInt64: + case EOpConstructUint64: case EOpConstructBool: case EOpConstructFloat: case EOpConstructDouble: @@ -472,6 +476,12 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EOpConstructUint: promoteTo = EbtUint; break; + case EOpConstructInt64: + promoteTo = EbtInt64; + break; + case EOpConstructUint64: + promoteTo = EbtUint64; + break; // // List all the binary ops that can implicitly convert one operand to the other's type; @@ -498,6 +508,9 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EOpAnd: case EOpInclusiveOr: case EOpExclusiveOr: + case EOpAndAssign: + case EOpInclusiveOrAssign: + case EOpExclusiveOrAssign: case EOpFunctionCall: case EOpReturn: @@ -531,9 +544,13 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EOpLeftShiftAssign: case EOpRightShiftAssign: if ((type.getBasicType() == EbtInt || - type.getBasicType() == EbtUint) && + type.getBasicType() == EbtUint || + type.getBasicType() == EbtInt64 || + type.getBasicType() == EbtUint64) && (node->getType().getBasicType() == EbtInt || - node->getType().getBasicType() == EbtUint)) + node->getType().getBasicType() == EbtUint || + node->getType().getBasicType() == EbtInt64 || + node->getType().getBasicType() == EbtUint64)) return node; else @@ -567,6 +584,8 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EbtUint: newOp = EOpConvUintToDouble; break; case EbtBool: newOp = EOpConvBoolToDouble; break; case EbtFloat: newOp = EOpConvFloatToDouble; break; + case EbtInt64: newOp = EOpConvInt64ToDouble; break; + case EbtUint64: newOp = EOpConvUint64ToDouble; break; default: return 0; } @@ -577,6 +596,8 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EbtUint: newOp = EOpConvUintToFloat; break; case EbtBool: newOp = EOpConvBoolToFloat; break; case EbtDouble: newOp = EOpConvDoubleToFloat; break; + case EbtInt64: newOp = EOpConvInt64ToFloat; break; + case EbtUint64: newOp = EOpConvUint64ToFloat; break; default: return 0; } @@ -587,6 +608,8 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EbtUint: newOp = EOpConvUintToBool; break; case EbtFloat: newOp = EOpConvFloatToBool; break; case EbtDouble: newOp = EOpConvDoubleToBool; break; + case EbtInt64: newOp = EOpConvInt64ToBool; break; + case EbtUint64: newOp = EOpConvUint64ToBool; break; default: return 0; } @@ -597,6 +620,8 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EbtBool: newOp = EOpConvBoolToInt; break; case EbtFloat: newOp = EOpConvFloatToInt; break; case EbtDouble: newOp = EOpConvDoubleToInt; break; + case EbtInt64: newOp = EOpConvInt64ToInt; break; + case EbtUint64: newOp = EOpConvUint64ToInt; break; default: return 0; } @@ -607,6 +632,32 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EbtBool: newOp = EOpConvBoolToUint; break; case EbtFloat: newOp = EOpConvFloatToUint; break; case EbtDouble: newOp = EOpConvDoubleToUint; break; + case EbtInt64: newOp = EOpConvInt64ToUint; break; + case EbtUint64: newOp = EOpConvUint64ToUint; break; + default: + return 0; + } + break; + case EbtInt64: + switch (node->getBasicType()) { + case EbtInt: newOp = EOpConvIntToInt64; break; + case EbtUint: newOp = EOpConvUintToInt64; break; + case EbtBool: newOp = EOpConvBoolToInt64; break; + case EbtFloat: newOp = EOpConvFloatToInt64; break; + case EbtDouble: newOp = EOpConvDoubleToInt64; break; + case EbtUint64: newOp = EOpConvUint64ToInt64; break; + default: + return 0; + } + break; + case EbtUint64: + switch (node->getBasicType()) { + case EbtInt: newOp = EOpConvIntToUint64; break; + case EbtUint: newOp = EOpConvUintToUint64; break; + case EbtBool: newOp = EOpConvBoolToUint64; break; + case EbtFloat: newOp = EOpConvFloatToUint64; break; + case EbtDouble: newOp = EOpConvDoubleToUint64; break; + case EbtInt64: newOp = EOpConvInt64ToUint64; break; default: return 0; } @@ -643,6 +694,8 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to) const switch (from) { case EbtInt: case EbtUint: + case EbtInt64: + case EbtUint64: case EbtFloat: case EbtDouble: return true; @@ -674,6 +727,24 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to) const default: return false; } + case EbtUint64: + switch (from) { + case EbtInt: + case EbtUint: + case EbtInt64: + case EbtUint64: + return true; + default: + return false; + } + case EbtInt64: + switch (from) { + case EbtInt: + case EbtInt64: + return true; + default: + return false; + } default: return false; } @@ -873,6 +944,22 @@ TIntermConstantUnion* TIntermediate::addConstantUnion(unsigned int u, const TSou return addConstantUnion(unionArray, TType(EbtUint, EvqConst), loc, literal); } +TIntermConstantUnion* TIntermediate::addConstantUnion(long long i64, const TSourceLoc& loc, bool literal) const +{ + TConstUnionArray unionArray(1); + unionArray[0].setI64Const(i64); + + return addConstantUnion(unionArray, TType(EbtInt64, EvqConst), loc, literal); +} + +TIntermConstantUnion* TIntermediate::addConstantUnion(unsigned long long u64, const TSourceLoc& loc, bool literal) const +{ + TConstUnionArray unionArray(1); + unionArray[0].setU64Const(u64); + + return addConstantUnion(unionArray, TType(EbtUint64, EvqConst), loc, literal); +} + TIntermConstantUnion* TIntermediate::addConstantUnion(bool b, const TSourceLoc& loc, bool literal) const { TConstUnionArray unionArray(1); @@ -1212,7 +1299,9 @@ bool TIntermUnary::promote() break; case EOpBitwiseNot: if (operand->getBasicType() != EbtInt && - operand->getBasicType() != EbtUint) + operand->getBasicType() != EbtUint && + operand->getBasicType() != EbtInt64 && + operand->getBasicType() != EbtUint64) return false; break; @@ -1223,6 +1312,8 @@ bool TIntermUnary::promote() case EOpPreDecrement: if (operand->getBasicType() != EbtInt && operand->getBasicType() != EbtUint && + operand->getBasicType() != EbtInt64 && + operand->getBasicType() != EbtUint64 && operand->getBasicType() != EbtFloat && operand->getBasicType() != EbtDouble) @@ -1340,8 +1431,10 @@ bool TIntermBinary::promote() case EOpInclusiveOrAssign: case EOpExclusiveOrAssign: // Check for integer-only operands. - if (( left->getBasicType() != EbtInt && left->getBasicType() != EbtUint) || - (right->getBasicType() != EbtInt && right->getBasicType() != EbtUint)) + if ((left->getBasicType() != EbtInt && left->getBasicType() != EbtUint && + left->getBasicType() != EbtInt64 && left->getBasicType() != EbtUint64) || + (right->getBasicType() != EbtInt && right->getBasicType() != EbtUint && + right->getBasicType() != EbtInt64 && right->getBasicType() != EbtUint64)) return false; if (left->isMatrix() || right->isMatrix()) return false; @@ -1643,6 +1736,12 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC case EbtUint: leftUnionArray[i].setDConst(static_cast(rightUnionArray[i].getUConst())); break; + case EbtInt64: + leftUnionArray[i].setDConst(static_cast(rightUnionArray[i].getI64Const())); + break; + case EbtUint64: + leftUnionArray[i].setDConst(static_cast(rightUnionArray[i].getU64Const())); + break; case EbtBool: leftUnionArray[i].setDConst(static_cast(rightUnionArray[i].getBConst())); break; @@ -1664,6 +1763,12 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC case EbtUint: leftUnionArray[i].setDConst(static_cast(rightUnionArray[i].getUConst())); break; + case EbtInt64: + leftUnionArray[i].setDConst(static_cast(rightUnionArray[i].getI64Const())); + break; + case EbtUint64: + leftUnionArray[i].setDConst(static_cast(rightUnionArray[i].getU64Const())); + break; case EbtBool: leftUnionArray[i].setDConst(static_cast(rightUnionArray[i].getBConst())); break; @@ -1683,6 +1788,12 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC case EbtUint: leftUnionArray[i].setIConst(static_cast(rightUnionArray[i].getUConst())); break; + case EbtInt64: + leftUnionArray[i].setIConst(static_cast(rightUnionArray[i].getI64Const())); + break; + case EbtUint64: + leftUnionArray[i].setIConst(static_cast(rightUnionArray[i].getU64Const())); + break; case EbtBool: leftUnionArray[i].setIConst(static_cast(rightUnionArray[i].getBConst())); break; @@ -1702,6 +1813,12 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC case EbtUint: leftUnionArray[i] = rightUnionArray[i]; break; + case EbtInt64: + leftUnionArray[i].setUConst(static_cast(rightUnionArray[i].getI64Const())); + break; + case EbtUint64: + leftUnionArray[i].setUConst(static_cast(rightUnionArray[i].getU64Const())); + break; case EbtBool: leftUnionArray[i].setUConst(static_cast(rightUnionArray[i].getBConst())); break; @@ -1721,6 +1838,12 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC case EbtUint: leftUnionArray[i].setBConst(rightUnionArray[i].getUConst() != 0); break; + case EbtInt64: + leftUnionArray[i].setBConst(rightUnionArray[i].getI64Const() != 0); + break; + case EbtUint64: + leftUnionArray[i].setBConst(rightUnionArray[i].getU64Const() != 0); + break; case EbtBool: leftUnionArray[i] = rightUnionArray[i]; break; @@ -1732,6 +1855,56 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC return node; } break; + case EbtInt64: + switch (node->getType().getBasicType()) { + case EbtInt: + leftUnionArray[i].setI64Const(static_cast(rightUnionArray[i].getIConst())); + break; + case EbtUint: + leftUnionArray[i].setI64Const(static_cast(rightUnionArray[i].getUConst())); + break; + case EbtInt64: + leftUnionArray[i] = rightUnionArray[i]; + break; + case EbtUint64: + leftUnionArray[i].setI64Const(static_cast(rightUnionArray[i].getU64Const())); + break; + case EbtBool: + leftUnionArray[i].setI64Const(static_cast(rightUnionArray[i].getBConst())); + break; + case EbtFloat: + case EbtDouble: + leftUnionArray[i].setI64Const(static_cast(rightUnionArray[i].getDConst())); + break; + default: + return node; + } + break; + case EbtUint64: + switch (node->getType().getBasicType()) { + case EbtInt: + leftUnionArray[i].setU64Const(static_cast(rightUnionArray[i].getIConst())); + break; + case EbtUint: + leftUnionArray[i].setU64Const(static_cast(rightUnionArray[i].getUConst())); + break; + case EbtInt64: + leftUnionArray[i].setU64Const(static_cast(rightUnionArray[i].getI64Const())); + break; + case EbtUint64: + leftUnionArray[i] = rightUnionArray[i]; + break; + case EbtBool: + leftUnionArray[i].setU64Const(static_cast(rightUnionArray[i].getBConst())); + break; + case EbtFloat: + case EbtDouble: + leftUnionArray[i].setU64Const(static_cast(rightUnionArray[i].getDConst())); + break; + default: + return node; + } + break; default: return node; } diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp index 4c1b7a0c..c9ca5d30 100644 --- a/glslang/MachineIndependent/ParseHelper.cpp +++ b/glslang/MachineIndependent/ParseHelper.cpp @@ -1812,6 +1812,24 @@ TOperator TParseContext::mapTypeToConstructorOp(const TType& type) const default: break; // some compilers want this } break; + case EbtInt64: + switch(type.getVectorSize()) { + case 1: op = EOpConstructInt64; break; + case 2: op = EOpConstructI64Vec2; break; + case 3: op = EOpConstructI64Vec3; break; + case 4: op = EOpConstructI64Vec4; break; + default: break; // some compilers want this + } + break; + case EbtUint64: + switch(type.getVectorSize()) { + case 1: op = EOpConstructUint64; break; + case 2: op = EOpConstructU64Vec2; break; + case 3: op = EOpConstructU64Vec3; break; + case 4: op = EOpConstructU64Vec4; break; + default: break; // some compilers want this + } + break; case EbtBool: switch(type.getVectorSize()) { case 1: op = EOpConstructBool; break; @@ -2534,13 +2552,19 @@ void TParseContext::globalQualifierTypeCheck(const TSourceLoc& loc, const TQuali return; } - if (publicType.basicType == EbtInt || publicType.basicType == EbtUint || publicType.basicType == EbtDouble) + if (publicType.basicType == EbtInt || publicType.basicType == EbtUint || + publicType.basicType == EbtInt64 || publicType.basicType == EbtUint64 || + publicType.basicType == EbtDouble) profileRequires(loc, EEsProfile, 300, nullptr, "shader input/output"); if (! qualifier.flat) { - if (publicType.basicType == EbtInt || publicType.basicType == EbtUint || publicType.basicType == EbtDouble || - (publicType.userDef && (publicType.userDef->containsBasicType(EbtInt) || - publicType.userDef->containsBasicType(EbtUint) || + if (publicType.basicType == EbtInt || publicType.basicType == EbtUint || + publicType.basicType == EbtInt64 || publicType.basicType == EbtUint64 || + publicType.basicType == EbtDouble || + (publicType.userDef && (publicType.userDef->containsBasicType(EbtInt) || + publicType.userDef->containsBasicType(EbtUint) || + publicType.userDef->containsBasicType(EbtInt64) || + publicType.userDef->containsBasicType(EbtUint64) || publicType.userDef->containsBasicType(EbtDouble)))) { if (qualifier.storage == EvqVaryingIn && language == EShLangFragment) error(loc, "must be qualified as flat", TType::getBasicString(publicType.basicType), GetStorageQualifierString(qualifier.storage)); @@ -4415,6 +4439,8 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type) { case EbtInt: case EbtUint: + case EbtInt64: + case EbtUint64: case EbtBool: case EbtFloat: case EbtDouble: @@ -5226,6 +5252,20 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T basicOp = EOpConstructUint; break; + case EOpConstructI64Vec2: + case EOpConstructI64Vec3: + case EOpConstructI64Vec4: + case EOpConstructInt64: + basicOp = EOpConstructInt64; + break; + + case EOpConstructU64Vec2: + case EOpConstructU64Vec3: + case EOpConstructU64Vec4: + case EOpConstructUint64: + basicOp = EOpConstructUint64; + break; + case EOpConstructBVec2: case EOpConstructBVec3: case EOpConstructBVec4: diff --git a/glslang/MachineIndependent/Scan.cpp b/glslang/MachineIndependent/Scan.cpp index 098f0bd0..762fb86c 100644 --- a/glslang/MachineIndependent/Scan.cpp +++ b/glslang/MachineIndependent/Scan.cpp @@ -454,6 +454,15 @@ void TScanContext::fillInKeywordMap() (*KeywordMap)["uvec3"] = UVEC3; (*KeywordMap)["uvec4"] = UVEC4; + (*KeywordMap)["int64_t"] = INT64_T; + (*KeywordMap)["uint64_t"] = UINT64_T; + (*KeywordMap)["i64vec2"] = I64VEC2; + (*KeywordMap)["i64vec3"] = I64VEC3; + (*KeywordMap)["i64vec4"] = I64VEC4; + (*KeywordMap)["u64vec2"] = U64VEC2; + (*KeywordMap)["u64vec3"] = U64VEC3; + (*KeywordMap)["u64vec4"] = U64VEC4; + (*KeywordMap)["sampler2D"] = SAMPLER2D; (*KeywordMap)["samplerCube"] = SAMPLERCUBE; (*KeywordMap)["samplerCubeArray"] = SAMPLERCUBEARRAY; @@ -667,10 +676,12 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token) case PpAtomDecrement: return DEC_OP; case PpAtomIncrement: return INC_OP; - case PpAtomConstInt: parserToken->sType.lex.i = ppToken.ival; return INTCONSTANT; - case PpAtomConstUint: parserToken->sType.lex.i = ppToken.ival; return UINTCONSTANT; - case PpAtomConstFloat: parserToken->sType.lex.d = ppToken.dval; return FLOATCONSTANT; - case PpAtomConstDouble: parserToken->sType.lex.d = ppToken.dval; return DOUBLECONSTANT; + case PpAtomConstInt: parserToken->sType.lex.i = ppToken.ival; return INTCONSTANT; + 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; + case PpAtomConstFloat: parserToken->sType.lex.d = ppToken.dval; return FLOATCONSTANT; + case PpAtomConstDouble: parserToken->sType.lex.d = ppToken.dval; return DOUBLECONSTANT; case PpAtomIdentifier: { int token = tokenizeIdentifier(); @@ -914,6 +925,18 @@ int TScanContext::tokenizeIdentifier() reservedWord(); return keyword; + case INT64_T: + case UINT64_T: + case I64VEC2: + case I64VEC3: + case I64VEC4: + case U64VEC2: + case U64VEC3: + case U64VEC4: + if (parseContext.profile != EEsProfile && parseContext.version >= 450) + return keyword; + return identifierOrType(); + case SAMPLERCUBEARRAY: case SAMPLERCUBEARRAYSHADOW: case ISAMPLERCUBEARRAY: diff --git a/glslang/MachineIndependent/SymbolTable.cpp b/glslang/MachineIndependent/SymbolTable.cpp index 75f50402..4c9b0e2c 100644 --- a/glslang/MachineIndependent/SymbolTable.cpp +++ b/glslang/MachineIndependent/SymbolTable.cpp @@ -62,6 +62,8 @@ void TType::buildMangledName(TString& mangledName) case EbtDouble: mangledName += 'd'; break; case EbtInt: mangledName += 'i'; break; case EbtUint: mangledName += 'u'; break; + case EbtInt64: mangledName += "i64"; break; + case EbtUint64: mangledName += "u64"; break; 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 af2f7f26..019caf9b 100644 --- a/glslang/MachineIndependent/Versions.cpp +++ b/glslang/MachineIndependent/Versions.cpp @@ -174,6 +174,7 @@ void TParseVersions::initializeExtensionBehavior() extensionBehavior[E_GL_ARB_derivative_control] = EBhDisable; extensionBehavior[E_GL_ARB_shader_texture_image_samples] = EBhDisable; extensionBehavior[E_GL_ARB_viewport_array] = EBhDisable; + extensionBehavior[E_GL_ARB_gpu_shader_int64] = EBhDisable; extensionBehavior[E_GL_ARB_gl_spirv] = EBhDisable; extensionBehavior[E_GL_ARB_sparse_texture2] = EBhDisable; extensionBehavior[E_GL_ARB_sparse_texture_clamp] = EBhDisable; @@ -278,6 +279,7 @@ const char* TParseVersions::getPreamble() "#define GL_ARB_derivative_control 1\n" "#define GL_ARB_shader_texture_image_samples 1\n" "#define GL_ARB_viewport_array 1\n" + "#define GL_ARB_gpu_shader_int64 1\n" "#define GL_ARB_gl_spirv 1\n" "#define GL_ARB_sparse_texture2 1\n" "#define GL_ARB_sparse_texture_clamp 1\n" @@ -627,6 +629,17 @@ void TParseVersions::doubleCheck(const TSourceLoc& loc, const char* op) profileRequires(loc, ECompatibilityProfile, 400, nullptr, op); } +// Call for any operation needing GLSL 64-bit integer data-type support. +void TParseVersions::int64Check(const TSourceLoc& loc, const char* op, bool builtIn) +{ + if (! builtIn) { + requireExtensions(loc, 1, &E_GL_ARB_gpu_shader_int64, "shader int64"); + requireProfile(loc, ECoreProfile | ECompatibilityProfile, op); + profileRequires(loc, ECoreProfile, 450, nullptr, op); + profileRequires(loc, ECompatibilityProfile, 450, nullptr, op); + } +} + // Call for any operation removed because SPIR-V is in use. void TParseVersions::spvRemoved(const TSourceLoc& loc, const char* op) { diff --git a/glslang/MachineIndependent/Versions.h b/glslang/MachineIndependent/Versions.h index d022d876..779ba9f2 100644 --- a/glslang/MachineIndependent/Versions.h +++ b/glslang/MachineIndependent/Versions.h @@ -111,6 +111,7 @@ const char* const E_GL_ARB_shader_draw_parameters = "GL_ARB_shader_draw_pa const char* const E_GL_ARB_derivative_control = "GL_ARB_derivative_control"; const char* const E_GL_ARB_shader_texture_image_samples = "GL_ARB_shader_texture_image_samples"; const char* const E_GL_ARB_viewport_array = "GL_ARB_viewport_array"; +const char* const E_GL_ARB_gpu_shader_int64 = "GL_ARB_gpu_shader_int64"; const char* const E_GL_ARB_gl_spirv = "GL_ARB_gl_spirv"; const char* const E_GL_ARB_sparse_texture2 = "GL_ARB_sparse_texture2"; const char* const E_GL_ARB_sparse_texture_clamp = "GL_ARB_sparse_texture_clamp"; diff --git a/glslang/MachineIndependent/gl_types.h b/glslang/MachineIndependent/gl_types.h index 91603b5b..9e877d37 100644 --- a/glslang/MachineIndependent/gl_types.h +++ b/glslang/MachineIndependent/gl_types.h @@ -41,6 +41,16 @@ #define GL_UNSIGNED_INT_VEC3 0x8DC7 #define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT64_ARB 0x140E +#define GL_INT64_VEC2_ARB 0x8FE9 +#define GL_INT64_VEC3_ARB 0x8FEA +#define GL_INT64_VEC4_ARB 0x8FEB + +#define GL_UNSIGNED_INT64_ARB 0x140F +#define GL_UNSIGNED_INT64_VEC2_ARB 0x8FE5 +#define GL_UNSIGNED_INT64_VEC3_ARB 0x8FE6 +#define GL_UNSIGNED_INT64_VEC4_ARB 0x8FE7 + #define GL_BOOL 0x8B56 #define GL_BOOL_VEC2 0x8B57 #define GL_BOOL_VEC3 0x8B58 diff --git a/glslang/MachineIndependent/glslang.y b/glslang/MachineIndependent/glslang.y index 847bcc9a..976c9952 100644 --- a/glslang/MachineIndependent/glslang.y +++ b/glslang/MachineIndependent/glslang.y @@ -70,6 +70,8 @@ using namespace glslang; glslang::TString *string; int i; unsigned int u; + long long i64; + unsigned long long u64; bool b; double d; }; @@ -117,9 +119,9 @@ 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 +%token CONST BOOL FLOAT DOUBLE INT UINT INT64_T UINT64_T %token BREAK CONTINUE DO ELSE FOR IF DISCARD RETURN SWITCH CASE DEFAULT SUBROUTINE -%token BVEC2 BVEC3 BVEC4 IVEC2 IVEC3 IVEC4 UVEC2 UVEC3 UVEC4 VEC2 VEC3 VEC4 +%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 %token UNIFORM PATCH SAMPLE BUFFER SHARED %token COHERENT VOLATILE RESTRICT READONLY WRITEONLY @@ -180,7 +182,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %token STRUCT VOID WHILE %token IDENTIFIER TYPE_NAME -%token FLOATCONSTANT DOUBLECONSTANT INTCONSTANT UINTCONSTANT BOOLCONSTANT +%token FLOATCONSTANT DOUBLECONSTANT INTCONSTANT UINTCONSTANT INT64CONSTANT UINT64CONSTANT BOOLCONSTANT %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 @@ -257,6 +259,14 @@ primary_expression parseContext.fullIntegerCheck($1.loc, "unsigned literal"); $$ = parseContext.intermediate.addConstantUnion($1.u, $1.loc, true); } + | INT64CONSTANT { + parseContext.int64Check($1.loc, "64-bit integer literal"); + $$ = parseContext.intermediate.addConstantUnion($1.i64, $1.loc, true); + } + | UINT64CONSTANT { + parseContext.int64Check($1.loc, "64-bit unsigned integer literal"); + $$ = parseContext.intermediate.addConstantUnion($1.u64, $1.loc, true); + } | FLOATCONSTANT { $$ = parseContext.intermediate.addConstantUnion($1.d, EbtFloat, $1.loc, true); } @@ -1309,6 +1319,16 @@ type_specifier_nonarray $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); $$.basicType = EbtUint; } + | INT64_T { + parseContext.int64Check($1.loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtInt64; + } + | UINT64_T { + parseContext.int64Check($1.loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtUint64; + } | BOOL { $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); $$.basicType = EbtBool; @@ -1376,6 +1396,24 @@ type_specifier_nonarray $$.basicType = EbtInt; $$.setVector(4); } + | I64VEC2 { + parseContext.int64Check($1.loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtInt64; + $$.setVector(2); + } + | I64VEC3 { + parseContext.int64Check($1.loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtInt64; + $$.setVector(3); + } + | I64VEC4 { + parseContext.int64Check($1.loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtInt64; + $$.setVector(4); + } | UVEC2 { parseContext.fullIntegerCheck($1.loc, "unsigned integer vector"); $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); @@ -1394,6 +1432,24 @@ type_specifier_nonarray $$.basicType = EbtUint; $$.setVector(4); } + | U64VEC2 { + parseContext.int64Check($1.loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtUint64; + $$.setVector(2); + } + | U64VEC3 { + parseContext.int64Check($1.loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtUint64; + $$.setVector(3); + } + | U64VEC4 { + parseContext.int64Check($1.loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtUint64; + $$.setVector(4); + } | MAT2 { $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); $$.basicType = EbtFloat; diff --git a/glslang/MachineIndependent/glslang_tab.cpp b/glslang/MachineIndependent/glslang_tab.cpp index d435aa80..18c1a2fa 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp +++ b/glslang/MachineIndependent/glslang_tab.cpp @@ -63,7 +63,7 @@ /* Copy the first part of user declarations. */ /* Line 371 of yacc.c */ -#line 41 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 41 "glslang.y" /* Based on: @@ -89,7 +89,7 @@ using namespace glslang; /* Line 371 of yacc.c */ -#line 93 "C:/Projects/glslang/glslang/MachineIndependent/glslang_tab.cpp" +#line 93 "glslang_tab.cpp" # ifndef YY_NULL # if defined __cplusplus && 201103L <= __cplusplus @@ -109,8 +109,8 @@ using namespace glslang; /* In a future release of Bison, this section will be replaced by #include "glslang_tab.cpp.h". */ -#ifndef YY_YY_C_PROJECTS_GLSLANG_GLSLANG_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED -# define YY_YY_C_PROJECTS_GLSLANG_GLSLANG_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED +#ifndef YY_YY_GLSLANG_TAB_CPP_H_INCLUDED +# define YY_YY_GLSLANG_TAB_CPP_H_INCLUDED /* Enabling traces. */ #ifndef YYDEBUG # define YYDEBUG 1 @@ -133,255 +133,265 @@ extern int yydebug; DOUBLE = 263, INT = 264, UINT = 265, - BREAK = 266, - CONTINUE = 267, - DO = 268, - ELSE = 269, - FOR = 270, - IF = 271, - DISCARD = 272, - RETURN = 273, - SWITCH = 274, - CASE = 275, - DEFAULT = 276, - SUBROUTINE = 277, - BVEC2 = 278, - BVEC3 = 279, - BVEC4 = 280, - IVEC2 = 281, - IVEC3 = 282, - IVEC4 = 283, - UVEC2 = 284, - UVEC3 = 285, - UVEC4 = 286, - VEC2 = 287, - VEC3 = 288, - VEC4 = 289, - MAT2 = 290, - MAT3 = 291, - MAT4 = 292, - CENTROID = 293, - IN = 294, - OUT = 295, - INOUT = 296, - UNIFORM = 297, - PATCH = 298, - SAMPLE = 299, - BUFFER = 300, - SHARED = 301, - COHERENT = 302, - VOLATILE = 303, - RESTRICT = 304, - READONLY = 305, - WRITEONLY = 306, - DVEC2 = 307, - DVEC3 = 308, - DVEC4 = 309, - DMAT2 = 310, - DMAT3 = 311, - DMAT4 = 312, - NOPERSPECTIVE = 313, - FLAT = 314, - SMOOTH = 315, - LAYOUT = 316, - MAT2X2 = 317, - MAT2X3 = 318, - MAT2X4 = 319, - MAT3X2 = 320, - MAT3X3 = 321, - MAT3X4 = 322, - MAT4X2 = 323, - MAT4X3 = 324, - MAT4X4 = 325, - DMAT2X2 = 326, - DMAT2X3 = 327, - DMAT2X4 = 328, - DMAT3X2 = 329, - DMAT3X3 = 330, - DMAT3X4 = 331, - DMAT4X2 = 332, - DMAT4X3 = 333, - DMAT4X4 = 334, - ATOMIC_UINT = 335, - SAMPLER1D = 336, - SAMPLER2D = 337, - SAMPLER3D = 338, - SAMPLERCUBE = 339, - SAMPLER1DSHADOW = 340, - SAMPLER2DSHADOW = 341, - SAMPLERCUBESHADOW = 342, - SAMPLER1DARRAY = 343, - SAMPLER2DARRAY = 344, - SAMPLER1DARRAYSHADOW = 345, - SAMPLER2DARRAYSHADOW = 346, - ISAMPLER1D = 347, - ISAMPLER2D = 348, - ISAMPLER3D = 349, - ISAMPLERCUBE = 350, - ISAMPLER1DARRAY = 351, - ISAMPLER2DARRAY = 352, - USAMPLER1D = 353, - USAMPLER2D = 354, - USAMPLER3D = 355, - USAMPLERCUBE = 356, - USAMPLER1DARRAY = 357, - USAMPLER2DARRAY = 358, - SAMPLER2DRECT = 359, - SAMPLER2DRECTSHADOW = 360, - ISAMPLER2DRECT = 361, - USAMPLER2DRECT = 362, - SAMPLERBUFFER = 363, - ISAMPLERBUFFER = 364, - USAMPLERBUFFER = 365, - SAMPLERCUBEARRAY = 366, - SAMPLERCUBEARRAYSHADOW = 367, - ISAMPLERCUBEARRAY = 368, - USAMPLERCUBEARRAY = 369, - SAMPLER2DMS = 370, - ISAMPLER2DMS = 371, - USAMPLER2DMS = 372, - SAMPLER2DMSARRAY = 373, - ISAMPLER2DMSARRAY = 374, - USAMPLER2DMSARRAY = 375, - SAMPLEREXTERNALOES = 376, - SAMPLER = 377, - SAMPLERSHADOW = 378, - TEXTURE1D = 379, - TEXTURE2D = 380, - TEXTURE3D = 381, - TEXTURECUBE = 382, - TEXTURE1DARRAY = 383, - TEXTURE2DARRAY = 384, - ITEXTURE1D = 385, - ITEXTURE2D = 386, - ITEXTURE3D = 387, - ITEXTURECUBE = 388, - ITEXTURE1DARRAY = 389, - ITEXTURE2DARRAY = 390, - UTEXTURE1D = 391, - UTEXTURE2D = 392, - UTEXTURE3D = 393, - UTEXTURECUBE = 394, - UTEXTURE1DARRAY = 395, - UTEXTURE2DARRAY = 396, - TEXTURE2DRECT = 397, - ITEXTURE2DRECT = 398, - UTEXTURE2DRECT = 399, - TEXTUREBUFFER = 400, - ITEXTUREBUFFER = 401, - UTEXTUREBUFFER = 402, - TEXTURECUBEARRAY = 403, - ITEXTURECUBEARRAY = 404, - UTEXTURECUBEARRAY = 405, - TEXTURE2DMS = 406, - ITEXTURE2DMS = 407, - UTEXTURE2DMS = 408, - TEXTURE2DMSARRAY = 409, - ITEXTURE2DMSARRAY = 410, - UTEXTURE2DMSARRAY = 411, - SUBPASSINPUT = 412, - SUBPASSINPUTMS = 413, - ISUBPASSINPUT = 414, - ISUBPASSINPUTMS = 415, - USUBPASSINPUT = 416, - USUBPASSINPUTMS = 417, - IMAGE1D = 418, - IIMAGE1D = 419, - UIMAGE1D = 420, - IMAGE2D = 421, - IIMAGE2D = 422, - UIMAGE2D = 423, - IMAGE3D = 424, - IIMAGE3D = 425, - UIMAGE3D = 426, - IMAGE2DRECT = 427, - IIMAGE2DRECT = 428, - UIMAGE2DRECT = 429, - IMAGECUBE = 430, - IIMAGECUBE = 431, - UIMAGECUBE = 432, - IMAGEBUFFER = 433, - IIMAGEBUFFER = 434, - UIMAGEBUFFER = 435, - IMAGE1DARRAY = 436, - IIMAGE1DARRAY = 437, - UIMAGE1DARRAY = 438, - IMAGE2DARRAY = 439, - IIMAGE2DARRAY = 440, - UIMAGE2DARRAY = 441, - IMAGECUBEARRAY = 442, - IIMAGECUBEARRAY = 443, - UIMAGECUBEARRAY = 444, - IMAGE2DMS = 445, - IIMAGE2DMS = 446, - UIMAGE2DMS = 447, - IMAGE2DMSARRAY = 448, - IIMAGE2DMSARRAY = 449, - UIMAGE2DMSARRAY = 450, - STRUCT = 451, - VOID = 452, - WHILE = 453, - IDENTIFIER = 454, - TYPE_NAME = 455, - FLOATCONSTANT = 456, - DOUBLECONSTANT = 457, - INTCONSTANT = 458, - UINTCONSTANT = 459, - BOOLCONSTANT = 460, - LEFT_OP = 461, - RIGHT_OP = 462, - INC_OP = 463, - DEC_OP = 464, - LE_OP = 465, - GE_OP = 466, - EQ_OP = 467, - NE_OP = 468, - AND_OP = 469, - OR_OP = 470, - XOR_OP = 471, - MUL_ASSIGN = 472, - DIV_ASSIGN = 473, - ADD_ASSIGN = 474, - MOD_ASSIGN = 475, - LEFT_ASSIGN = 476, - RIGHT_ASSIGN = 477, - AND_ASSIGN = 478, - XOR_ASSIGN = 479, - OR_ASSIGN = 480, - SUB_ASSIGN = 481, - LEFT_PAREN = 482, - RIGHT_PAREN = 483, - LEFT_BRACKET = 484, - RIGHT_BRACKET = 485, - LEFT_BRACE = 486, - RIGHT_BRACE = 487, - DOT = 488, - COMMA = 489, - COLON = 490, - EQUAL = 491, - SEMICOLON = 492, - BANG = 493, - DASH = 494, - TILDE = 495, - PLUS = 496, - STAR = 497, - SLASH = 498, - PERCENT = 499, - LEFT_ANGLE = 500, - RIGHT_ANGLE = 501, - VERTICAL_BAR = 502, - CARET = 503, - AMPERSAND = 504, - QUESTION = 505, - INVARIANT = 506, - PRECISE = 507, - HIGH_PRECISION = 508, - MEDIUM_PRECISION = 509, - LOW_PRECISION = 510, - PRECISION = 511, - PACKED = 512, - RESOURCE = 513, - SUPERP = 514 + INT64_T = 266, + UINT64_T = 267, + BREAK = 268, + CONTINUE = 269, + DO = 270, + ELSE = 271, + FOR = 272, + IF = 273, + DISCARD = 274, + RETURN = 275, + SWITCH = 276, + CASE = 277, + DEFAULT = 278, + SUBROUTINE = 279, + BVEC2 = 280, + BVEC3 = 281, + BVEC4 = 282, + IVEC2 = 283, + IVEC3 = 284, + IVEC4 = 285, + I64VEC2 = 286, + I64VEC3 = 287, + I64VEC4 = 288, + UVEC2 = 289, + UVEC3 = 290, + UVEC4 = 291, + U64VEC2 = 292, + U64VEC3 = 293, + U64VEC4 = 294, + VEC2 = 295, + VEC3 = 296, + VEC4 = 297, + MAT2 = 298, + MAT3 = 299, + MAT4 = 300, + CENTROID = 301, + IN = 302, + OUT = 303, + INOUT = 304, + UNIFORM = 305, + PATCH = 306, + SAMPLE = 307, + BUFFER = 308, + SHARED = 309, + COHERENT = 310, + VOLATILE = 311, + RESTRICT = 312, + READONLY = 313, + WRITEONLY = 314, + DVEC2 = 315, + DVEC3 = 316, + DVEC4 = 317, + DMAT2 = 318, + DMAT3 = 319, + DMAT4 = 320, + NOPERSPECTIVE = 321, + FLAT = 322, + SMOOTH = 323, + LAYOUT = 324, + MAT2X2 = 325, + MAT2X3 = 326, + MAT2X4 = 327, + MAT3X2 = 328, + MAT3X3 = 329, + MAT3X4 = 330, + MAT4X2 = 331, + MAT4X3 = 332, + MAT4X4 = 333, + DMAT2X2 = 334, + DMAT2X3 = 335, + DMAT2X4 = 336, + DMAT3X2 = 337, + DMAT3X3 = 338, + DMAT3X4 = 339, + DMAT4X2 = 340, + DMAT4X3 = 341, + DMAT4X4 = 342, + ATOMIC_UINT = 343, + SAMPLER1D = 344, + SAMPLER2D = 345, + SAMPLER3D = 346, + SAMPLERCUBE = 347, + SAMPLER1DSHADOW = 348, + SAMPLER2DSHADOW = 349, + SAMPLERCUBESHADOW = 350, + SAMPLER1DARRAY = 351, + SAMPLER2DARRAY = 352, + SAMPLER1DARRAYSHADOW = 353, + SAMPLER2DARRAYSHADOW = 354, + ISAMPLER1D = 355, + ISAMPLER2D = 356, + ISAMPLER3D = 357, + ISAMPLERCUBE = 358, + ISAMPLER1DARRAY = 359, + ISAMPLER2DARRAY = 360, + USAMPLER1D = 361, + USAMPLER2D = 362, + USAMPLER3D = 363, + USAMPLERCUBE = 364, + USAMPLER1DARRAY = 365, + USAMPLER2DARRAY = 366, + SAMPLER2DRECT = 367, + SAMPLER2DRECTSHADOW = 368, + ISAMPLER2DRECT = 369, + USAMPLER2DRECT = 370, + SAMPLERBUFFER = 371, + ISAMPLERBUFFER = 372, + USAMPLERBUFFER = 373, + SAMPLERCUBEARRAY = 374, + SAMPLERCUBEARRAYSHADOW = 375, + ISAMPLERCUBEARRAY = 376, + USAMPLERCUBEARRAY = 377, + SAMPLER2DMS = 378, + ISAMPLER2DMS = 379, + USAMPLER2DMS = 380, + SAMPLER2DMSARRAY = 381, + ISAMPLER2DMSARRAY = 382, + USAMPLER2DMSARRAY = 383, + SAMPLEREXTERNALOES = 384, + SAMPLER = 385, + SAMPLERSHADOW = 386, + TEXTURE1D = 387, + TEXTURE2D = 388, + TEXTURE3D = 389, + TEXTURECUBE = 390, + TEXTURE1DARRAY = 391, + TEXTURE2DARRAY = 392, + ITEXTURE1D = 393, + ITEXTURE2D = 394, + ITEXTURE3D = 395, + ITEXTURECUBE = 396, + ITEXTURE1DARRAY = 397, + ITEXTURE2DARRAY = 398, + UTEXTURE1D = 399, + UTEXTURE2D = 400, + UTEXTURE3D = 401, + UTEXTURECUBE = 402, + UTEXTURE1DARRAY = 403, + UTEXTURE2DARRAY = 404, + TEXTURE2DRECT = 405, + ITEXTURE2DRECT = 406, + UTEXTURE2DRECT = 407, + TEXTUREBUFFER = 408, + ITEXTUREBUFFER = 409, + UTEXTUREBUFFER = 410, + TEXTURECUBEARRAY = 411, + ITEXTURECUBEARRAY = 412, + UTEXTURECUBEARRAY = 413, + TEXTURE2DMS = 414, + ITEXTURE2DMS = 415, + UTEXTURE2DMS = 416, + TEXTURE2DMSARRAY = 417, + ITEXTURE2DMSARRAY = 418, + UTEXTURE2DMSARRAY = 419, + SUBPASSINPUT = 420, + SUBPASSINPUTMS = 421, + ISUBPASSINPUT = 422, + ISUBPASSINPUTMS = 423, + USUBPASSINPUT = 424, + USUBPASSINPUTMS = 425, + IMAGE1D = 426, + IIMAGE1D = 427, + UIMAGE1D = 428, + IMAGE2D = 429, + IIMAGE2D = 430, + UIMAGE2D = 431, + IMAGE3D = 432, + IIMAGE3D = 433, + UIMAGE3D = 434, + IMAGE2DRECT = 435, + IIMAGE2DRECT = 436, + UIMAGE2DRECT = 437, + IMAGECUBE = 438, + IIMAGECUBE = 439, + UIMAGECUBE = 440, + IMAGEBUFFER = 441, + IIMAGEBUFFER = 442, + UIMAGEBUFFER = 443, + IMAGE1DARRAY = 444, + IIMAGE1DARRAY = 445, + UIMAGE1DARRAY = 446, + IMAGE2DARRAY = 447, + IIMAGE2DARRAY = 448, + UIMAGE2DARRAY = 449, + IMAGECUBEARRAY = 450, + IIMAGECUBEARRAY = 451, + UIMAGECUBEARRAY = 452, + IMAGE2DMS = 453, + IIMAGE2DMS = 454, + UIMAGE2DMS = 455, + IMAGE2DMSARRAY = 456, + IIMAGE2DMSARRAY = 457, + UIMAGE2DMSARRAY = 458, + STRUCT = 459, + VOID = 460, + WHILE = 461, + IDENTIFIER = 462, + TYPE_NAME = 463, + FLOATCONSTANT = 464, + DOUBLECONSTANT = 465, + INTCONSTANT = 466, + UINTCONSTANT = 467, + INT64CONSTANT = 468, + UINT64CONSTANT = 469, + BOOLCONSTANT = 470, + LEFT_OP = 471, + RIGHT_OP = 472, + INC_OP = 473, + DEC_OP = 474, + LE_OP = 475, + GE_OP = 476, + EQ_OP = 477, + NE_OP = 478, + AND_OP = 479, + OR_OP = 480, + XOR_OP = 481, + MUL_ASSIGN = 482, + DIV_ASSIGN = 483, + ADD_ASSIGN = 484, + MOD_ASSIGN = 485, + LEFT_ASSIGN = 486, + RIGHT_ASSIGN = 487, + AND_ASSIGN = 488, + XOR_ASSIGN = 489, + OR_ASSIGN = 490, + SUB_ASSIGN = 491, + LEFT_PAREN = 492, + RIGHT_PAREN = 493, + LEFT_BRACKET = 494, + RIGHT_BRACKET = 495, + LEFT_BRACE = 496, + RIGHT_BRACE = 497, + DOT = 498, + COMMA = 499, + COLON = 500, + EQUAL = 501, + SEMICOLON = 502, + BANG = 503, + DASH = 504, + TILDE = 505, + PLUS = 506, + STAR = 507, + SLASH = 508, + PERCENT = 509, + LEFT_ANGLE = 510, + RIGHT_ANGLE = 511, + VERTICAL_BAR = 512, + CARET = 513, + AMPERSAND = 514, + QUESTION = 515, + INVARIANT = 516, + PRECISE = 517, + HIGH_PRECISION = 518, + MEDIUM_PRECISION = 519, + LOW_PRECISION = 520, + PRECISION = 521, + PACKED = 522, + RESOURCE = 523, + SUPERP = 524 }; #endif @@ -390,7 +400,7 @@ extern int yydebug; typedef union YYSTYPE { /* Line 387 of yacc.c */ -#line 66 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 66 "glslang.y" struct { glslang::TSourceLoc loc; @@ -398,6 +408,8 @@ typedef union YYSTYPE glslang::TString *string; int i; unsigned int u; + long long i64; + unsigned long long u64; bool b; double d; }; @@ -424,7 +436,7 @@ typedef union YYSTYPE /* Line 387 of yacc.c */ -#line 428 "C:/Projects/glslang/glslang/MachineIndependent/glslang_tab.cpp" +#line 440 "glslang_tab.cpp" } YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ @@ -446,11 +458,11 @@ int yyparse (); #endif #endif /* ! YYPARSE_PARAM */ -#endif /* !YY_YY_C_PROJECTS_GLSLANG_GLSLANG_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED */ +#endif /* !YY_YY_GLSLANG_TAB_CPP_H_INCLUDED */ /* Copy the second part of user declarations. */ /* Line 390 of yacc.c */ -#line 98 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 100 "glslang.y" /* windows only pragma */ @@ -467,7 +479,7 @@ extern int yylex(YYSTYPE*, TParseContext&); /* Line 390 of yacc.c */ -#line 471 "C:/Projects/glslang/glslang/MachineIndependent/glslang_tab.cpp" +#line 483 "glslang_tab.cpp" #ifdef short # undef short @@ -685,22 +697,22 @@ union yyalloc #endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ -#define YYFINAL 240 +#define YYFINAL 248 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 5659 +#define YYLAST 5943 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 260 +#define YYNTOKENS 270 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 100 /* YYNRULES -- Number of rules. */ -#define YYNRULES 411 +#define YYNRULES 421 /* YYNRULES -- Number of states. */ -#define YYNSTATES 543 +#define YYNSTATES 553 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 514 +#define YYMAXUTOK 524 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) @@ -759,7 +771,8 @@ static const yytype_uint16 yytranslate[] = 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259 + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269 }; #if YYDEBUG @@ -768,23 +781,23 @@ static const yytype_uint16 yytranslate[] = static const yytype_uint16 yyprhs[] = { 0, 0, 3, 5, 7, 9, 11, 13, 15, 17, - 21, 23, 28, 30, 34, 37, 40, 42, 44, 46, - 49, 52, 55, 57, 60, 64, 67, 69, 71, 73, - 76, 79, 82, 84, 86, 88, 90, 92, 96, 100, - 104, 106, 110, 114, 116, 120, 124, 126, 130, 134, - 138, 142, 144, 148, 152, 154, 158, 160, 164, 166, - 170, 172, 176, 178, 182, 184, 188, 190, 191, 198, - 200, 204, 206, 208, 210, 212, 214, 216, 218, 220, - 222, 224, 226, 228, 232, 234, 237, 240, 245, 248, - 252, 257, 260, 264, 269, 270, 277, 280, 284, 287, - 289, 291, 294, 298, 302, 305, 309, 312, 314, 317, - 319, 321, 323, 327, 332, 339, 345, 347, 350, 354, - 360, 365, 367, 370, 372, 374, 376, 378, 383, 385, - 389, 391, 395, 397, 399, 401, 404, 406, 408, 410, + 19, 21, 25, 27, 32, 34, 38, 41, 44, 46, + 48, 50, 53, 56, 59, 61, 64, 68, 71, 73, + 75, 77, 80, 83, 86, 88, 90, 92, 94, 96, + 100, 104, 108, 110, 114, 118, 120, 124, 128, 130, + 134, 138, 142, 146, 148, 152, 156, 158, 162, 164, + 168, 170, 174, 176, 180, 182, 186, 188, 192, 194, + 195, 202, 204, 208, 210, 212, 214, 216, 218, 220, + 222, 224, 226, 228, 230, 232, 236, 238, 241, 244, + 249, 252, 256, 261, 264, 268, 273, 274, 281, 284, + 288, 291, 293, 295, 298, 302, 306, 309, 313, 316, + 318, 321, 323, 325, 327, 331, 336, 343, 349, 351, + 354, 358, 364, 369, 371, 374, 376, 378, 380, 382, + 387, 389, 393, 395, 399, 401, 403, 405, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, - 452, 457, 459, 463, 465, 468, 471, 475, 479, 484, - 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, + 452, 454, 456, 461, 463, 467, 469, 472, 475, 479, + 483, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, @@ -800,172 +813,176 @@ static const yytype_uint16 yyprhs[] = 746, 748, 750, 752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776, 778, 780, 782, 784, 786, 788, 790, 792, 794, 796, 798, 800, 802, 804, - 806, 808, 810, 812, 814, 816, 817, 824, 825, 831, - 833, 836, 840, 845, 847, 851, 853, 856, 858, 862, - 867, 869, 873, 875, 877, 879, 881, 883, 885, 887, - 889, 891, 893, 896, 897, 898, 904, 906, 908, 909, - 912, 913, 916, 919, 923, 925, 928, 930, 933, 939, - 943, 945, 947, 952, 953, 962, 963, 965, 969, 972, - 973, 980, 981, 990, 991, 999, 1001, 1003, 1005, 1006, - 1009, 1013, 1016, 1019, 1022, 1026, 1029, 1031, 1034, 1036, - 1038, 1039 + 806, 808, 810, 812, 814, 816, 818, 820, 822, 824, + 826, 828, 830, 832, 834, 836, 837, 844, 845, 851, + 853, 856, 860, 865, 867, 871, 873, 876, 878, 882, + 887, 889, 893, 895, 897, 899, 901, 903, 905, 907, + 909, 911, 913, 916, 917, 918, 924, 926, 928, 929, + 932, 933, 936, 939, 943, 945, 948, 950, 953, 959, + 963, 965, 967, 972, 973, 982, 983, 985, 989, 992, + 993, 1000, 1001, 1010, 1011, 1019, 1021, 1023, 1025, 1026, + 1029, 1033, 1036, 1039, 1042, 1046, 1049, 1051, 1054, 1056, + 1058, 1059 }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ static const yytype_int16 yyrhs[] = { - 356, 0, -1, 199, -1, 261, -1, 203, -1, 204, - -1, 201, -1, 202, -1, 205, -1, 227, 289, 228, - -1, 262, -1, 263, 229, 264, 230, -1, 265, -1, - 263, 233, 199, -1, 263, 208, -1, 263, 209, -1, - 289, -1, 266, -1, 267, -1, 269, 228, -1, 268, - 228, -1, 270, 197, -1, 270, -1, 270, 287, -1, - 269, 234, 287, -1, 271, 227, -1, 315, -1, 263, - -1, 263, -1, 208, 272, -1, 209, 272, -1, 273, - 272, -1, 241, -1, 239, -1, 238, -1, 240, -1, - 272, -1, 274, 242, 272, -1, 274, 243, 272, -1, - 274, 244, 272, -1, 274, -1, 275, 241, 274, -1, - 275, 239, 274, -1, 275, -1, 276, 206, 275, -1, - 276, 207, 275, -1, 276, -1, 277, 245, 276, -1, - 277, 246, 276, -1, 277, 210, 276, -1, 277, 211, - 276, -1, 277, -1, 278, 212, 277, -1, 278, 213, - 277, -1, 278, -1, 279, 249, 278, -1, 279, -1, - 280, 248, 279, -1, 280, -1, 281, 247, 280, -1, - 281, -1, 282, 214, 281, -1, 282, -1, 283, 216, - 282, -1, 283, -1, 284, 215, 283, -1, 284, -1, - -1, 284, 250, 286, 289, 235, 287, -1, 285, -1, - 272, 288, 287, -1, 236, -1, 217, -1, 218, -1, - 220, -1, 219, -1, 226, -1, 221, -1, 222, -1, - 223, -1, 224, -1, 225, -1, 287, -1, 289, 234, - 287, -1, 285, -1, 295, 237, -1, 302, 237, -1, - 256, 318, 315, 237, -1, 292, 237, -1, 292, 199, - 237, -1, 292, 199, 316, 237, -1, 311, 237, -1, - 311, 199, 237, -1, 311, 199, 294, 237, -1, -1, - 311, 199, 231, 293, 322, 232, -1, 234, 199, -1, - 294, 234, 199, -1, 296, 228, -1, 298, -1, 297, - -1, 298, 300, -1, 297, 234, 300, -1, 304, 199, - 227, -1, 315, 199, -1, 315, 199, 316, -1, 311, - 299, -1, 299, -1, 311, 301, -1, 301, -1, 315, - -1, 303, -1, 302, 234, 199, -1, 302, 234, 199, - 316, -1, 302, 234, 199, 316, 236, 326, -1, 302, - 234, 199, 236, 326, -1, 304, -1, 304, 199, -1, - 304, 199, 316, -1, 304, 199, 316, 236, 326, -1, - 304, 199, 236, 326, -1, 315, -1, 311, 315, -1, - 251, -1, 60, -1, 59, -1, 58, -1, 61, 227, - 308, 228, -1, 309, -1, 308, 234, 309, -1, 199, - -1, 199, 236, 290, -1, 46, -1, 252, -1, 312, - -1, 311, 312, -1, 313, -1, 307, -1, 318, -1, - 306, -1, 305, -1, 310, -1, 5, -1, 3, -1, - 4, -1, 41, -1, 39, -1, 40, -1, 38, -1, - 43, -1, 44, -1, 42, -1, 45, -1, 46, -1, - 47, -1, 48, -1, 49, -1, 50, -1, 51, -1, - 22, -1, 22, 227, 314, 228, -1, 200, -1, 314, - 234, 200, -1, 317, -1, 317, 316, -1, 229, 230, - -1, 229, 285, 230, -1, 316, 229, 230, -1, 316, - 229, 285, 230, -1, 197, -1, 7, -1, 8, -1, - 9, -1, 10, -1, 6, -1, 32, -1, 33, -1, - 34, -1, 52, -1, 53, -1, 54, -1, 23, -1, - 24, -1, 25, -1, 26, -1, 27, -1, 28, -1, - 29, -1, 30, -1, 31, -1, 35, -1, 36, -1, - 37, -1, 62, -1, 63, -1, 64, -1, 65, -1, - 66, -1, 67, -1, 68, -1, 69, -1, 70, -1, - 55, -1, 56, -1, 57, -1, 71, -1, 72, -1, - 73, -1, 74, -1, 75, -1, 76, -1, 77, -1, - 78, -1, 79, -1, 80, -1, 81, -1, 82, -1, - 83, -1, 84, -1, 85, -1, 86, -1, 87, -1, - 88, -1, 89, -1, 90, -1, 91, -1, 111, -1, - 112, -1, 92, -1, 93, -1, 94, -1, 95, -1, - 96, -1, 97, -1, 113, -1, 98, -1, 99, -1, - 100, -1, 101, -1, 102, -1, 103, -1, 114, -1, - 104, -1, 105, -1, 106, -1, 107, -1, 108, -1, - 109, -1, 110, -1, 115, -1, 116, -1, 117, -1, - 118, -1, 119, -1, 120, -1, 122, -1, 123, -1, - 124, -1, 125, -1, 126, -1, 127, -1, 128, -1, - 129, -1, 148, -1, 130, -1, 131, -1, 132, -1, - 133, -1, 134, -1, 135, -1, 149, -1, 136, -1, - 137, -1, 138, -1, 139, -1, 140, -1, 141, -1, - 150, -1, 142, -1, 143, -1, 144, -1, 145, -1, - 146, -1, 147, -1, 151, -1, 152, -1, 153, -1, - 154, -1, 155, -1, 156, -1, 163, -1, 164, -1, - 165, -1, 166, -1, 167, -1, 168, -1, 169, -1, - 170, -1, 171, -1, 172, -1, 173, -1, 174, -1, - 175, -1, 176, -1, 177, -1, 178, -1, 179, -1, - 180, -1, 181, -1, 182, -1, 183, -1, 184, -1, - 185, -1, 186, -1, 187, -1, 188, -1, 189, -1, - 190, -1, 191, -1, 192, -1, 193, -1, 194, -1, - 195, -1, 121, -1, 157, -1, 158, -1, 159, -1, - 160, -1, 161, -1, 162, -1, 319, -1, 200, -1, - 253, -1, 254, -1, 255, -1, -1, 196, 199, 231, - 320, 322, 232, -1, -1, 196, 231, 321, 322, 232, - -1, 323, -1, 322, 323, -1, 315, 324, 237, -1, - 311, 315, 324, 237, -1, 325, -1, 324, 234, 325, - -1, 199, -1, 199, 316, -1, 287, -1, 231, 327, - 232, -1, 231, 327, 234, 232, -1, 326, -1, 327, - 234, 326, -1, 291, -1, 331, -1, 330, -1, 328, - -1, 340, -1, 341, -1, 344, -1, 347, -1, 348, - -1, 355, -1, 231, 232, -1, -1, -1, 231, 332, - 339, 333, 232, -1, 338, -1, 330, -1, -1, 336, - 331, -1, -1, 337, 330, -1, 231, 232, -1, 231, - 339, 232, -1, 329, -1, 339, 329, -1, 237, -1, - 289, 237, -1, 16, 227, 289, 228, 342, -1, 335, - 14, 335, -1, 335, -1, 289, -1, 304, 199, 236, - 326, -1, -1, 19, 227, 289, 228, 345, 231, 346, - 232, -1, -1, 339, -1, 20, 289, 235, -1, 21, - 235, -1, -1, 198, 227, 349, 343, 228, 334, -1, - -1, 13, 350, 329, 198, 227, 289, 228, 237, -1, - -1, 15, 227, 351, 352, 354, 228, 334, -1, 340, - -1, 328, -1, 343, -1, -1, 353, 237, -1, 353, - 237, 289, -1, 12, 237, -1, 11, 237, -1, 18, - 237, -1, 18, 289, 237, -1, 17, 237, -1, 357, - -1, 356, 357, -1, 358, -1, 291, -1, -1, 295, - 359, 338, -1 + 366, 0, -1, 207, -1, 271, -1, 211, -1, 212, + -1, 213, -1, 214, -1, 209, -1, 210, -1, 215, + -1, 237, 299, 238, -1, 272, -1, 273, 239, 274, + 240, -1, 275, -1, 273, 243, 207, -1, 273, 218, + -1, 273, 219, -1, 299, -1, 276, -1, 277, -1, + 279, 238, -1, 278, 238, -1, 280, 205, -1, 280, + -1, 280, 297, -1, 279, 244, 297, -1, 281, 237, + -1, 325, -1, 273, -1, 273, -1, 218, 282, -1, + 219, 282, -1, 283, 282, -1, 251, -1, 249, -1, + 248, -1, 250, -1, 282, -1, 284, 252, 282, -1, + 284, 253, 282, -1, 284, 254, 282, -1, 284, -1, + 285, 251, 284, -1, 285, 249, 284, -1, 285, -1, + 286, 216, 285, -1, 286, 217, 285, -1, 286, -1, + 287, 255, 286, -1, 287, 256, 286, -1, 287, 220, + 286, -1, 287, 221, 286, -1, 287, -1, 288, 222, + 287, -1, 288, 223, 287, -1, 288, -1, 289, 259, + 288, -1, 289, -1, 290, 258, 289, -1, 290, -1, + 291, 257, 290, -1, 291, -1, 292, 224, 291, -1, + 292, -1, 293, 226, 292, -1, 293, -1, 294, 225, + 293, -1, 294, -1, -1, 294, 260, 296, 299, 245, + 297, -1, 295, -1, 282, 298, 297, -1, 246, -1, + 227, -1, 228, -1, 230, -1, 229, -1, 236, -1, + 231, -1, 232, -1, 233, -1, 234, -1, 235, -1, + 297, -1, 299, 244, 297, -1, 295, -1, 305, 247, + -1, 312, 247, -1, 266, 328, 325, 247, -1, 302, + 247, -1, 302, 207, 247, -1, 302, 207, 326, 247, + -1, 321, 247, -1, 321, 207, 247, -1, 321, 207, + 304, 247, -1, -1, 321, 207, 241, 303, 332, 242, + -1, 244, 207, -1, 304, 244, 207, -1, 306, 238, + -1, 308, -1, 307, -1, 308, 310, -1, 307, 244, + 310, -1, 314, 207, 237, -1, 325, 207, -1, 325, + 207, 326, -1, 321, 309, -1, 309, -1, 321, 311, + -1, 311, -1, 325, -1, 313, -1, 312, 244, 207, + -1, 312, 244, 207, 326, -1, 312, 244, 207, 326, + 246, 336, -1, 312, 244, 207, 246, 336, -1, 314, + -1, 314, 207, -1, 314, 207, 326, -1, 314, 207, + 326, 246, 336, -1, 314, 207, 246, 336, -1, 325, + -1, 321, 325, -1, 261, -1, 68, -1, 67, -1, + 66, -1, 69, 237, 318, 238, -1, 319, -1, 318, + 244, 319, -1, 207, -1, 207, 246, 300, -1, 54, + -1, 262, -1, 322, -1, 321, 322, -1, 323, -1, + 317, -1, 328, -1, 316, -1, 315, -1, 320, -1, + 5, -1, 3, -1, 4, -1, 49, -1, 47, -1, + 48, -1, 46, -1, 51, -1, 52, -1, 50, -1, + 53, -1, 54, -1, 55, -1, 56, -1, 57, -1, + 58, -1, 59, -1, 24, -1, 24, 237, 324, 238, + -1, 208, -1, 324, 244, 208, -1, 327, -1, 327, + 326, -1, 239, 240, -1, 239, 295, 240, -1, 326, + 239, 240, -1, 326, 239, 295, 240, -1, 205, -1, + 7, -1, 8, -1, 9, -1, 10, -1, 11, -1, + 12, -1, 6, -1, 40, -1, 41, -1, 42, -1, + 60, -1, 61, -1, 62, -1, 25, -1, 26, -1, + 27, -1, 28, -1, 29, -1, 30, -1, 31, -1, + 32, -1, 33, -1, 34, -1, 35, -1, 36, -1, + 37, -1, 38, -1, 39, -1, 43, -1, 44, -1, + 45, -1, 70, -1, 71, -1, 72, -1, 73, -1, + 74, -1, 75, -1, 76, -1, 77, -1, 78, -1, + 63, -1, 64, -1, 65, -1, 79, -1, 80, -1, + 81, -1, 82, -1, 83, -1, 84, -1, 85, -1, + 86, -1, 87, -1, 88, -1, 89, -1, 90, -1, + 91, -1, 92, -1, 93, -1, 94, -1, 95, -1, + 96, -1, 97, -1, 98, -1, 99, -1, 119, -1, + 120, -1, 100, -1, 101, -1, 102, -1, 103, -1, + 104, -1, 105, -1, 121, -1, 106, -1, 107, -1, + 108, -1, 109, -1, 110, -1, 111, -1, 122, -1, + 112, -1, 113, -1, 114, -1, 115, -1, 116, -1, + 117, -1, 118, -1, 123, -1, 124, -1, 125, -1, + 126, -1, 127, -1, 128, -1, 130, -1, 131, -1, + 132, -1, 133, -1, 134, -1, 135, -1, 136, -1, + 137, -1, 156, -1, 138, -1, 139, -1, 140, -1, + 141, -1, 142, -1, 143, -1, 157, -1, 144, -1, + 145, -1, 146, -1, 147, -1, 148, -1, 149, -1, + 158, -1, 150, -1, 151, -1, 152, -1, 153, -1, + 154, -1, 155, -1, 159, -1, 160, -1, 161, -1, + 162, -1, 163, -1, 164, -1, 171, -1, 172, -1, + 173, -1, 174, -1, 175, -1, 176, -1, 177, -1, + 178, -1, 179, -1, 180, -1, 181, -1, 182, -1, + 183, -1, 184, -1, 185, -1, 186, -1, 187, -1, + 188, -1, 189, -1, 190, -1, 191, -1, 192, -1, + 193, -1, 194, -1, 195, -1, 196, -1, 197, -1, + 198, -1, 199, -1, 200, -1, 201, -1, 202, -1, + 203, -1, 129, -1, 165, -1, 166, -1, 167, -1, + 168, -1, 169, -1, 170, -1, 329, -1, 208, -1, + 263, -1, 264, -1, 265, -1, -1, 204, 207, 241, + 330, 332, 242, -1, -1, 204, 241, 331, 332, 242, + -1, 333, -1, 332, 333, -1, 325, 334, 247, -1, + 321, 325, 334, 247, -1, 335, -1, 334, 244, 335, + -1, 207, -1, 207, 326, -1, 297, -1, 241, 337, + 242, -1, 241, 337, 244, 242, -1, 336, -1, 337, + 244, 336, -1, 301, -1, 341, -1, 340, -1, 338, + -1, 350, -1, 351, -1, 354, -1, 357, -1, 358, + -1, 365, -1, 241, 242, -1, -1, -1, 241, 342, + 349, 343, 242, -1, 348, -1, 340, -1, -1, 346, + 341, -1, -1, 347, 340, -1, 241, 242, -1, 241, + 349, 242, -1, 339, -1, 349, 339, -1, 247, -1, + 299, 247, -1, 18, 237, 299, 238, 352, -1, 345, + 16, 345, -1, 345, -1, 299, -1, 314, 207, 246, + 336, -1, -1, 21, 237, 299, 238, 355, 241, 356, + 242, -1, -1, 349, -1, 22, 299, 245, -1, 23, + 245, -1, -1, 206, 237, 359, 353, 238, 344, -1, + -1, 15, 360, 339, 206, 237, 299, 238, 247, -1, + -1, 17, 237, 361, 362, 364, 238, 344, -1, 350, + -1, 338, -1, 353, -1, -1, 363, 247, -1, 363, + 247, 299, -1, 14, 247, -1, 13, 247, -1, 20, + 247, -1, 20, 299, 247, -1, 19, 247, -1, 367, + -1, 366, 367, -1, 368, -1, 301, -1, -1, 305, + 369, 348, -1 }; /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { - 0, 244, 244, 250, 253, 256, 260, 263, 267, 270, - 278, 281, 284, 287, 290, 295, 303, 310, 317, 323, - 327, 334, 337, 343, 350, 360, 368, 373, 403, 409, - 413, 417, 437, 438, 439, 440, 446, 447, 452, 457, - 466, 467, 472, 480, 481, 487, 496, 497, 502, 507, - 512, 520, 521, 529, 540, 541, 550, 551, 560, 561, - 570, 571, 579, 580, 588, 589, 597, 598, 598, 616, - 617, 632, 636, 640, 644, 649, 653, 657, 661, 665, - 669, 673, 680, 683, 693, 700, 705, 710, 718, 722, - 726, 730, 735, 740, 749, 749, 760, 764, 771, 778, - 781, 788, 796, 816, 834, 849, 872, 883, 893, 903, - 913, 922, 925, 929, 933, 938, 946, 951, 956, 961, - 966, 975, 986, 1013, 1022, 1029, 1036, 1046, 1052, 1055, - 1062, 1066, 1070, 1078, 1084, 1087, 1098, 1101, 1104, 1107, - 1111, 1115, 1122, 1126, 1138, 1152, 1157, 1163, 1169, 1176, - 1182, 1187, 1192, 1197, 1204, 1208, 1212, 1216, 1220, 1224, - 1230, 1242, 1245, 1250, 1254, 1263, 1268, 1276, 1280, 1290, - 1294, 1298, 1303, 1307, 1312, 1316, 1321, 1326, 1331, 1337, - 1343, 1349, 1354, 1359, 1364, 1369, 1374, 1379, 1385, 1391, - 1397, 1402, 1407, 1412, 1417, 1422, 1427, 1432, 1437, 1442, - 1447, 1452, 1457, 1463, 1469, 1475, 1481, 1487, 1493, 1499, - 1505, 1511, 1517, 1523, 1529, 1534, 1539, 1544, 1549, 1554, - 1559, 1564, 1569, 1574, 1579, 1584, 1589, 1594, 1599, 1604, - 1609, 1614, 1619, 1624, 1629, 1634, 1639, 1644, 1649, 1654, - 1659, 1664, 1669, 1674, 1679, 1684, 1689, 1694, 1699, 1704, - 1709, 1714, 1719, 1724, 1729, 1734, 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, 2080, 2086, 2092, 2098, 2104, 2110, - 2116, 2121, 2137, 2143, 2149, 2158, 2158, 2169, 2169, 2179, - 2182, 2195, 2213, 2237, 2241, 2247, 2252, 2263, 2266, 2272, - 2281, 2284, 2290, 2294, 2295, 2301, 2302, 2303, 2304, 2305, - 2306, 2307, 2311, 2312, 2316, 2312, 2328, 2329, 2333, 2333, - 2340, 2340, 2354, 2357, 2365, 2373, 2384, 2385, 2389, 2396, - 2400, 2408, 2412, 2425, 2425, 2445, 2448, 2454, 2466, 2478, - 2478, 2493, 2493, 2509, 2509, 2530, 2533, 2539, 2542, 2548, - 2552, 2559, 2564, 2569, 2576, 2594, 2603, 2607, 2614, 2617, - 2623, 2623 + 0, 246, 246, 252, 255, 258, 262, 266, 270, 273, + 277, 280, 288, 291, 294, 297, 300, 305, 313, 320, + 327, 333, 337, 344, 347, 353, 360, 370, 378, 383, + 413, 419, 423, 427, 447, 448, 449, 450, 456, 457, + 462, 467, 476, 477, 482, 490, 491, 497, 506, 507, + 512, 517, 522, 530, 531, 539, 550, 551, 560, 561, + 570, 571, 580, 581, 589, 590, 598, 599, 607, 608, + 608, 626, 627, 642, 646, 650, 654, 659, 663, 667, + 671, 675, 679, 683, 690, 693, 703, 710, 715, 720, + 728, 732, 736, 740, 745, 750, 759, 759, 770, 774, + 781, 788, 791, 798, 806, 826, 844, 859, 882, 893, + 903, 913, 923, 932, 935, 939, 943, 948, 956, 961, + 966, 971, 976, 985, 996, 1023, 1032, 1039, 1046, 1056, + 1062, 1065, 1072, 1076, 1080, 1088, 1094, 1097, 1108, 1111, + 1114, 1117, 1121, 1125, 1132, 1136, 1148, 1162, 1167, 1173, + 1179, 1186, 1192, 1197, 1202, 1207, 1214, 1218, 1222, 1226, + 1230, 1234, 1240, 1252, 1255, 1260, 1264, 1273, 1278, 1286, + 1290, 1300, 1304, 1308, 1313, 1317, 1322, 1327, 1332, 1336, + 1341, 1346, 1351, 1357, 1363, 1369, 1374, 1379, 1384, 1389, + 1394, 1399, 1405, 1411, 1417, 1423, 1429, 1435, 1441, 1447, + 1453, 1458, 1463, 1468, 1473, 1478, 1483, 1488, 1493, 1498, + 1503, 1508, 1513, 1519, 1525, 1531, 1537, 1543, 1549, 1555, + 1561, 1567, 1573, 1579, 1585, 1590, 1595, 1600, 1605, 1610, + 1615, 1620, 1625, 1630, 1635, 1640, 1645, 1650, 1655, 1660, + 1665, 1670, 1675, 1680, 1685, 1690, 1695, 1700, 1705, 1710, + 1715, 1720, 1725, 1730, 1735, 1740, 1745, 1750, 1755, 1760, + 1765, 1770, 1775, 1780, 1785, 1790, 1795, 1800, 1805, 1810, + 1815, 1820, 1825, 1830, 1835, 1840, 1845, 1850, 1855, 1860, + 1865, 1870, 1875, 1880, 1885, 1890, 1895, 1900, 1905, 1910, + 1915, 1920, 1925, 1930, 1935, 1940, 1945, 1950, 1955, 1960, + 1965, 1970, 1975, 1980, 1985, 1990, 1995, 2000, 2005, 2010, + 2015, 2020, 2025, 2030, 2035, 2040, 2045, 2050, 2055, 2060, + 2065, 2070, 2075, 2080, 2085, 2090, 2095, 2100, 2105, 2110, + 2115, 2120, 2125, 2130, 2136, 2142, 2148, 2154, 2160, 2166, + 2172, 2177, 2193, 2199, 2205, 2214, 2214, 2225, 2225, 2235, + 2238, 2251, 2269, 2293, 2297, 2303, 2308, 2319, 2322, 2328, + 2337, 2340, 2346, 2350, 2351, 2357, 2358, 2359, 2360, 2361, + 2362, 2363, 2367, 2368, 2372, 2368, 2384, 2385, 2389, 2389, + 2396, 2396, 2410, 2413, 2421, 2429, 2440, 2441, 2445, 2452, + 2456, 2464, 2468, 2481, 2481, 2501, 2504, 2510, 2522, 2534, + 2534, 2549, 2549, 2565, 2565, 2586, 2589, 2595, 2598, 2604, + 2608, 2615, 2620, 2625, 2632, 2650, 2659, 2663, 2670, 2673, + 2679, 2679 }; #endif @@ -975,14 +992,15 @@ static const yytype_uint16 yyrline[] = static const char *const yytname[] = { "$end", "error", "$undefined", "ATTRIBUTE", "VARYING", "CONST", "BOOL", - "FLOAT", "DOUBLE", "INT", "UINT", "BREAK", "CONTINUE", "DO", "ELSE", - "FOR", "IF", "DISCARD", "RETURN", "SWITCH", "CASE", "DEFAULT", - "SUBROUTINE", "BVEC2", "BVEC3", "BVEC4", "IVEC2", "IVEC3", "IVEC4", - "UVEC2", "UVEC3", "UVEC4", "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", - "NOPERSPECTIVE", "FLAT", "SMOOTH", "LAYOUT", "MAT2X2", "MAT2X3", + "FLOAT", "DOUBLE", "INT", "UINT", "INT64_T", "UINT64_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", "NOPERSPECTIVE", "FLAT", "SMOOTH", "LAYOUT", "MAT2X2", "MAT2X3", "MAT2X4", "MAT3X2", "MAT3X3", "MAT3X4", "MAT4X2", "MAT4X3", "MAT4X4", "DMAT2X2", "DMAT2X3", "DMAT2X4", "DMAT3X2", "DMAT3X3", "DMAT3X4", "DMAT4X2", "DMAT4X3", "DMAT4X4", "ATOMIC_UINT", "SAMPLER1D", "SAMPLER2D", @@ -1016,20 +1034,20 @@ static const char *const yytname[] = "UIMAGECUBEARRAY", "IMAGE2DMS", "IIMAGE2DMS", "UIMAGE2DMS", "IMAGE2DMSARRAY", "IIMAGE2DMSARRAY", "UIMAGE2DMSARRAY", "STRUCT", "VOID", "WHILE", "IDENTIFIER", "TYPE_NAME", "FLOATCONSTANT", "DOUBLECONSTANT", - "INTCONSTANT", "UINTCONSTANT", "BOOLCONSTANT", "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", + "INTCONSTANT", "UINTCONSTANT", "INT64CONSTANT", "UINT64CONSTANT", + "BOOLCONSTANT", "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", @@ -1093,77 +1111,80 @@ static const yytype_uint16 yytoknum[] = 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, - 505, 506, 507, 508, 509, 510, 511, 512, 513, 514 + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 521, 522, 523, 524 }; # endif /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint16 yyr1[] = { - 0, 260, 261, 262, 262, 262, 262, 262, 262, 262, - 263, 263, 263, 263, 263, 263, 264, 265, 266, 267, - 267, 268, 268, 269, 269, 270, 271, 271, 272, 272, - 272, 272, 273, 273, 273, 273, 274, 274, 274, 274, - 275, 275, 275, 276, 276, 276, 277, 277, 277, 277, - 277, 278, 278, 278, 279, 279, 280, 280, 281, 281, - 282, 282, 283, 283, 284, 284, 285, 286, 285, 287, - 287, 288, 288, 288, 288, 288, 288, 288, 288, 288, - 288, 288, 289, 289, 290, 291, 291, 291, 291, 291, - 291, 291, 291, 291, 293, 292, 294, 294, 295, 296, - 296, 297, 297, 298, 299, 299, 300, 300, 300, 300, - 301, 302, 302, 302, 302, 302, 303, 303, 303, 303, - 303, 304, 304, 305, 306, 306, 306, 307, 308, 308, - 309, 309, 309, 310, 311, 311, 312, 312, 312, 312, - 312, 312, 313, 313, 313, 313, 313, 313, 313, 313, - 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, - 313, 314, 314, 315, 315, 316, 316, 316, 316, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, - 317, 317, 318, 318, 318, 320, 319, 321, 319, 322, - 322, 323, 323, 324, 324, 325, 325, 326, 326, 326, - 327, 327, 328, 329, 329, 330, 330, 330, 330, 330, - 330, 330, 331, 332, 333, 331, 334, 334, 336, 335, - 337, 335, 338, 338, 339, 339, 340, 340, 341, 342, - 342, 343, 343, 345, 344, 346, 346, 347, 347, 349, - 348, 350, 348, 351, 348, 352, 352, 353, 353, 354, - 354, 355, 355, 355, 355, 355, 356, 356, 357, 357, - 359, 358 + 0, 270, 271, 272, 272, 272, 272, 272, 272, 272, + 272, 272, 273, 273, 273, 273, 273, 273, 274, 275, + 276, 277, 277, 278, 278, 279, 279, 280, 281, 281, + 282, 282, 282, 282, 283, 283, 283, 283, 284, 284, + 284, 284, 285, 285, 285, 286, 286, 286, 287, 287, + 287, 287, 287, 288, 288, 288, 289, 289, 290, 290, + 291, 291, 292, 292, 293, 293, 294, 294, 295, 296, + 295, 297, 297, 298, 298, 298, 298, 298, 298, 298, + 298, 298, 298, 298, 299, 299, 300, 301, 301, 301, + 301, 301, 301, 301, 301, 301, 303, 302, 304, 304, + 305, 306, 306, 307, 307, 308, 309, 309, 310, 310, + 310, 310, 311, 312, 312, 312, 312, 312, 313, 313, + 313, 313, 313, 314, 314, 315, 316, 316, 316, 317, + 318, 318, 319, 319, 319, 320, 321, 321, 322, 322, + 322, 322, 322, 322, 323, 323, 323, 323, 323, 323, + 323, 323, 323, 323, 323, 323, 323, 323, 323, 323, + 323, 323, 323, 324, 324, 325, 325, 326, 326, 326, + 326, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 327, 327, 327, 327, 327, 327, 327, 327, + 327, 327, 328, 328, 328, 330, 329, 331, 329, 332, + 332, 333, 333, 334, 334, 335, 335, 336, 336, 336, + 337, 337, 338, 339, 339, 340, 340, 340, 340, 340, + 340, 340, 341, 342, 343, 341, 344, 344, 346, 345, + 347, 345, 348, 348, 349, 349, 350, 350, 351, 352, + 352, 353, 353, 355, 354, 356, 356, 357, 357, 359, + 358, 360, 358, 361, 358, 362, 362, 363, 363, 364, + 364, 365, 365, 365, 365, 365, 366, 366, 367, 367, + 369, 368 }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ static const yytype_uint8 yyr2[] = { - 0, 2, 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, 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, 4, 1, 3, - 1, 3, 1, 1, 1, 2, 1, 1, 1, 1, + 0, 2, 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, 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, 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, - 4, 1, 3, 1, 2, 2, 3, 3, 4, 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, 1, 1, @@ -1196,367 +1217,220 @@ static const yytype_uint8 yyr2[] = means the default is an error. */ static const yytype_uint16 yydefact[] = { - 0, 143, 144, 142, 174, 170, 171, 172, 173, 159, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 175, - 176, 177, 190, 191, 192, 148, 146, 147, 145, 151, - 149, 150, 152, 153, 154, 155, 156, 157, 158, 178, - 179, 180, 202, 203, 204, 126, 125, 124, 0, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 228, - 229, 230, 231, 232, 233, 235, 236, 237, 238, 239, - 240, 242, 243, 244, 245, 246, 247, 248, 226, 227, - 234, 241, 249, 250, 251, 252, 253, 254, 323, 255, - 256, 257, 258, 259, 260, 261, 262, 264, 265, 266, - 267, 268, 269, 271, 272, 273, 274, 275, 276, 278, - 279, 280, 281, 282, 283, 263, 270, 277, 284, 285, - 286, 287, 288, 289, 324, 325, 326, 327, 328, 329, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 0, 169, 331, 123, 133, 332, 333, - 334, 0, 409, 0, 410, 0, 100, 99, 0, 111, - 116, 140, 139, 137, 141, 0, 134, 136, 121, 163, - 138, 330, 0, 406, 408, 0, 0, 0, 337, 0, - 0, 88, 85, 0, 98, 0, 107, 101, 109, 0, - 110, 0, 86, 117, 0, 91, 135, 122, 0, 164, - 1, 407, 161, 0, 132, 130, 0, 128, 335, 0, - 0, 89, 0, 0, 411, 102, 106, 108, 104, 112, - 103, 0, 118, 94, 0, 92, 0, 2, 6, 7, - 4, 5, 8, 0, 0, 0, 165, 34, 33, 35, - 32, 3, 10, 28, 12, 17, 18, 0, 0, 22, - 0, 36, 0, 40, 43, 46, 51, 54, 56, 58, - 60, 62, 64, 66, 0, 26, 0, 160, 0, 0, - 127, 0, 0, 0, 0, 0, 339, 87, 90, 0, - 0, 391, 0, 0, 0, 0, 0, 0, 0, 0, - 363, 372, 376, 36, 69, 82, 0, 352, 0, 121, - 355, 374, 354, 353, 0, 356, 357, 358, 359, 360, - 361, 105, 0, 113, 0, 347, 120, 0, 0, 96, - 0, 93, 29, 30, 0, 14, 15, 0, 0, 20, - 19, 0, 169, 23, 25, 31, 0, 0, 0, 0, + 0, 145, 146, 144, 178, 172, 173, 174, 175, 176, + 177, 161, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 179, 180, 181, + 200, 201, 202, 150, 148, 149, 147, 153, 151, 152, + 154, 155, 156, 157, 158, 159, 160, 182, 183, 184, + 212, 213, 214, 128, 127, 126, 0, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 238, 239, 240, + 241, 242, 243, 245, 246, 247, 248, 249, 250, 252, + 253, 254, 255, 256, 257, 258, 236, 237, 244, 251, + 259, 260, 261, 262, 263, 264, 333, 265, 266, 267, + 268, 269, 270, 271, 272, 274, 275, 276, 277, 278, + 279, 281, 282, 283, 284, 285, 286, 288, 289, 290, + 291, 292, 293, 273, 280, 287, 294, 295, 296, 297, + 298, 299, 334, 335, 336, 337, 338, 339, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 0, 171, 341, 125, 135, 342, 343, 344, 0, + 419, 0, 420, 0, 102, 101, 0, 113, 118, 142, + 141, 139, 143, 0, 136, 138, 123, 165, 140, 340, + 0, 416, 418, 0, 0, 0, 347, 0, 0, 90, + 87, 0, 100, 0, 109, 103, 111, 0, 112, 0, + 88, 119, 0, 93, 137, 124, 0, 166, 1, 417, + 163, 0, 134, 132, 0, 130, 345, 0, 0, 91, + 0, 0, 421, 104, 108, 110, 106, 114, 105, 0, + 120, 96, 0, 94, 0, 2, 8, 9, 4, 5, + 6, 7, 10, 0, 0, 0, 167, 36, 35, 37, + 34, 3, 12, 30, 14, 19, 20, 0, 0, 24, + 0, 38, 0, 42, 45, 48, 53, 56, 58, 60, + 62, 64, 66, 68, 0, 28, 0, 162, 0, 0, + 129, 0, 0, 0, 0, 0, 349, 89, 92, 0, + 0, 401, 0, 0, 0, 0, 0, 0, 0, 0, + 373, 382, 386, 38, 71, 84, 0, 362, 0, 123, + 365, 384, 364, 363, 0, 366, 367, 368, 369, 370, + 371, 107, 0, 115, 0, 357, 122, 0, 0, 98, + 0, 95, 31, 32, 0, 16, 17, 0, 0, 22, + 21, 0, 171, 25, 27, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 67, 166, 167, 0, 162, - 84, 131, 129, 0, 0, 345, 0, 343, 338, 340, - 402, 401, 0, 393, 0, 405, 403, 0, 0, 0, - 388, 389, 362, 0, 72, 73, 75, 74, 77, 78, - 79, 80, 81, 76, 71, 0, 0, 377, 373, 375, - 115, 0, 350, 0, 119, 0, 97, 9, 0, 16, - 13, 24, 37, 38, 39, 42, 41, 44, 45, 49, - 50, 47, 48, 52, 53, 55, 57, 59, 61, 63, - 65, 0, 168, 336, 0, 346, 0, 341, 0, 0, - 0, 404, 0, 387, 0, 364, 70, 83, 114, 348, - 0, 95, 11, 0, 342, 344, 0, 396, 395, 398, - 370, 383, 381, 0, 0, 0, 0, 349, 351, 0, - 0, 397, 0, 0, 380, 0, 0, 378, 0, 0, - 0, 365, 68, 0, 399, 0, 370, 369, 371, 385, - 0, 367, 390, 366, 0, 400, 394, 379, 386, 0, - 382, 392, 384 + 0, 0, 0, 0, 0, 69, 168, 169, 0, 164, + 86, 133, 131, 0, 0, 355, 0, 353, 348, 350, + 412, 411, 0, 403, 0, 415, 413, 0, 0, 0, + 398, 399, 372, 0, 74, 75, 77, 76, 79, 80, + 81, 82, 83, 78, 73, 0, 0, 387, 383, 385, + 117, 0, 360, 0, 121, 0, 99, 11, 0, 18, + 15, 26, 39, 40, 41, 44, 43, 46, 47, 51, + 52, 49, 50, 54, 55, 57, 59, 61, 63, 65, + 67, 0, 170, 346, 0, 356, 0, 351, 0, 0, + 0, 414, 0, 397, 0, 374, 72, 85, 116, 358, + 0, 97, 13, 0, 352, 354, 0, 406, 405, 408, + 380, 393, 391, 0, 0, 0, 0, 359, 361, 0, + 0, 407, 0, 0, 390, 0, 0, 388, 0, 0, + 0, 375, 70, 0, 409, 0, 380, 379, 381, 395, + 0, 377, 400, 376, 0, 410, 404, 389, 396, 0, + 392, 402, 394 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 281, 282, 283, 448, 284, 285, 286, 287, 288, - 289, 290, 333, 292, 293, 294, 295, 296, 297, 298, - 299, 300, 301, 302, 303, 334, 471, 335, 435, 336, - 401, 337, 193, 358, 266, 338, 195, 196, 197, 226, - 227, 228, 198, 199, 200, 201, 202, 203, 246, 247, - 204, 205, 206, 207, 243, 305, 239, 209, 210, 211, - 312, 249, 315, 316, 406, 407, 356, 443, 340, 341, - 342, 343, 423, 506, 532, 514, 515, 516, 533, 344, - 345, 346, 517, 505, 347, 518, 539, 348, 349, 484, - 412, 479, 499, 512, 513, 350, 212, 213, 214, 223 + -1, 291, 292, 293, 458, 294, 295, 296, 297, 298, + 299, 300, 343, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 344, 481, 345, 445, 346, + 411, 347, 201, 368, 274, 348, 203, 204, 205, 234, + 235, 236, 206, 207, 208, 209, 210, 211, 254, 255, + 212, 213, 214, 215, 251, 315, 247, 217, 218, 219, + 322, 257, 325, 326, 416, 417, 366, 453, 350, 351, + 352, 353, 433, 516, 542, 524, 525, 526, 543, 354, + 355, 356, 527, 515, 357, 528, 549, 358, 359, 494, + 422, 489, 509, 522, 523, 360, 220, 221, 222, 231 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -#define YYPACT_NINF -466 +#define YYPACT_NINF -496 static const yytype_int16 yypact[] = { - 2275, -466, -466, -466, -466, -466, -466, -466, -466, -205, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -192, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -179, -466, -466, -466, -466, -466, -466, - -466, -122, -466, -186, -198, -173, -175, 3686, -194, -466, - -121, -466, -466, -466, -466, 2749, -466, -466, -466, -141, - -466, -466, 527, -466, -466, -97, -37, -117, -466, 5459, - -200, -466, -466, -112, -466, 3686, -466, -466, -466, 3686, - -71, -44, -466, -191, -142, -466, -466, -466, 4117, -82, - -466, -466, -466, -202, -466, -76, -137, -466, -466, 3686, - -73, -466, -196, 781, -466, -466, -466, -466, -141, -155, - -466, 4342, -152, -466, -38, -466, -177, -466, -466, -466, - -466, -466, -466, 5015, 5015, 5015, -466, -466, -466, -466, - -466, -466, -466, -185, -466, -466, -466, -63, -128, 5237, - -61, -466, 5015, -106, -100, -157, -183, -78, -81, -79, - -80, -43, -46, -197, -58, -466, 4568, -466, -27, 5015, - -466, -37, 3686, 3686, -25, 2984, -466, -466, -466, -62, - -57, -466, -51, -48, -56, 4793, -45, 5015, -50, -40, - -41, -466, -466, -153, -466, -466, -147, -466, -198, -39, - -466, -466, -466, -466, 1035, -466, -466, -466, -466, -466, - -466, -82, 4342, -143, 4342, -466, -466, 4342, 3686, -466, - -15, -466, -466, -466, -126, -466, -466, 5015, -10, -466, - -466, 5015, -36, -466, -466, -466, 5015, 5015, 5015, 5015, - 5015, 5015, 5015, 5015, 5015, 5015, 5015, 5015, 5015, 5015, - 5015, 5015, 5015, 5015, 5015, -466, -466, -466, -35, -466, - -466, -466, -466, 3218, -25, -141, -127, -466, -466, -466, - -466, -466, 1289, -466, 5015, -466, -466, -108, 5015, -91, - -466, -466, -466, 1289, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, 5015, 5015, -466, -466, -466, - -466, 4342, -466, -92, -466, 3452, -466, -466, -34, -31, - -466, -466, -466, -466, -466, -106, -106, -100, -100, -157, - -157, -157, -157, -183, -183, -78, -81, -79, -80, -43, - -46, 5015, -466, -466, -107, -82, -25, -466, -4, 2036, - -123, -466, -116, -466, 2510, 1289, -466, -466, -466, -466, - 3890, -466, -466, -83, -466, -466, -29, -466, -466, 2510, - -32, -466, -31, 1, 3686, -24, -26, -466, -466, 5015, - 5015, -466, -30, -19, 196, -20, 1797, -466, -18, -22, - 1543, -466, -466, -113, 5015, 1543, -32, -466, -466, 1289, - 4342, -466, -466, -466, -17, -31, -466, -466, 1289, -14, - -466, -466, -466 + 2394, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -199, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -187, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -180, -496, -496, -496, -496, -496, -496, -496, -134, + -496, -191, -181, -155, -131, 3871, -133, -496, -69, -496, + -496, -496, -496, 2900, -496, -496, -496, -92, -496, -496, + 546, -496, -496, -68, -45, -91, -496, 5735, -200, -496, + -496, -85, -496, 3871, -496, -496, -496, 3871, -50, -49, + -496, -209, -193, -496, -496, -496, 4323, -80, -496, -496, + -496, -202, -496, -86, -171, -496, -496, 3871, -84, -496, + -198, 810, -496, -496, -496, -496, -92, -214, -496, 4558, + -176, -496, -46, -496, -127, -496, -496, -496, -496, -496, + -496, -496, -496, 5271, 5271, 5271, -496, -496, -496, -496, + -496, -496, -496, -175, -496, -496, -496, -73, -169, 5503, + -71, -496, 5271, -118, -170, -195, -197, -90, -89, -87, + -88, -57, -58, -208, -67, -496, 4804, -496, -36, 5271, + -496, -45, 3871, 3871, -33, 3145, -496, -496, -496, -72, + -70, -496, -61, -59, -66, 5039, -55, 5271, -62, -51, + -54, -496, -496, -141, -496, -496, -125, -496, -181, -48, + -496, -496, -496, -496, 1074, -496, -496, -496, -496, -496, + -496, -80, 4558, -174, 4558, -496, -496, 4558, 3871, -496, + -23, -496, -496, -496, -167, -496, -496, 5271, -20, -496, + -496, 5271, -43, -496, -496, -496, 5271, 5271, 5271, 5271, + 5271, 5271, 5271, 5271, 5271, 5271, 5271, 5271, 5271, 5271, + 5271, 5271, 5271, 5271, 5271, -496, -496, -496, -44, -496, + -496, -496, -496, 3387, -33, -92, -121, -496, -496, -496, + -496, -496, 1338, -496, 5271, -496, -496, -120, 5271, -102, + -496, -496, -496, 1338, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, 5271, 5271, -496, -496, -496, + -496, 4558, -496, -105, -496, 3629, -496, -496, -42, -52, + -496, -496, -496, -496, -496, -118, -118, -170, -170, -195, + -195, -195, -195, -197, -197, -90, -89, -87, -88, -57, + -58, 5271, -496, -496, -119, -80, -33, -496, -16, 2130, + -164, -496, -160, -496, 2637, 1338, -496, -496, -496, -496, + 4077, -496, -496, -99, -496, -496, -40, -496, -496, 2637, + -41, -496, -52, -8, 3871, -35, -38, -496, -496, 5271, + 5271, -496, -39, -32, 191, -31, 1866, -496, -30, -34, + 1602, -496, -496, -138, 5271, 1602, -41, -496, -496, 1338, + 4558, -496, -496, -496, -29, -52, -496, -496, 1338, -27, + -496, -496, -496 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -466, -466, -466, -466, -466, -466, -466, -466, -466, -466, - -466, -466, -52, -466, -226, -225, -261, -229, -166, -164, - -167, -165, -162, -161, -466, -227, -466, -258, -466, -269, - -466, 4, -466, -466, -466, 5, -466, -466, -466, -1, - 9, 6, -466, -466, -465, -466, -466, -466, -466, -75, - -466, -195, -204, -466, -466, 0, -212, -466, 46, -466, - -466, -466, -297, -299, -160, -238, -340, -466, -240, -337, - -440, -273, -466, -466, -282, -281, -466, -466, 23, -413, - -232, -466, -466, -251, -466, -466, -466, -466, -466, -466, - -466, -466, -466, -466, -466, -466, -466, 40, -466, -466 + -496, -496, -496, -496, -496, -496, -496, -496, -496, -496, + -496, -496, -53, -496, -237, -288, -286, -243, -183, -179, + -184, -177, -168, -185, -496, -234, -496, -266, -496, -280, + -496, 4, -496, -496, -496, 6, -496, -496, -496, -15, + -10, -9, -496, -496, -475, -496, -496, -496, -496, -83, + -496, -204, -211, -496, -496, 0, -221, -496, 33, -496, + -496, -496, -308, -314, -178, -247, -349, -496, -248, -346, + -495, -283, -496, -496, -292, -291, -496, -496, 13, -423, + -242, -496, -496, -263, -496, -496, -496, -496, -496, -496, + -496, -496, -496, -496, -496, -496, -496, 28, -496, -496 }; /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule which number is the opposite. If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -369 +#define YYTABLE_NINF -379 static const yytype_int16 yytable[] = { - 208, 236, 229, 355, 192, 194, 364, 439, 252, 244, - 485, 304, 440, 220, 442, 403, 409, 444, 394, 503, - 217, 262, 215, 365, 366, 236, 307, 383, 384, 238, - 229, 373, 308, 306, 503, 216, 260, 251, 238, 222, - 231, 318, -27, 232, 367, 261, 351, 353, 368, 381, - 382, 221, 218, 395, 313, 224, 417, 360, 419, 225, - 361, 445, 385, 386, 424, 425, 426, 427, 428, 429, - 430, 431, 432, 433, 238, 478, 528, 306, 233, 398, - 531, 352, 400, 434, 357, 531, 306, 436, 238, 263, - 437, 310, 264, 441, 355, 265, 355, 311, 449, 355, - 370, 488, 447, 242, 409, 500, 371, 476, 436, 236, - 477, 436, 501, 451, 248, 534, 538, 313, 436, 253, - 313, 436, 459, 460, 461, 462, 436, 476, 258, 481, - 494, 188, 189, 190, 387, 388, 376, 377, 378, 379, - 489, 380, 490, 436, 483, 480, 409, 306, 439, 482, - 508, 436, 509, 455, 456, 259, 457, 458, 463, 464, - 309, 359, 245, 313, 317, 369, 374, 391, 389, 390, - 393, 392, 396, 399, 405, 410, 413, 486, 487, 414, - 411, 415, 418, 355, 446, 420, 291, 421, -26, 450, - 540, 422, -21, 475, 496, 472, 492, 230, 510, -368, - 519, 439, 493, 436, 520, 237, 521, 524, 313, 525, - 526, 330, 208, 529, 530, 502, 192, 194, 542, 250, - 541, 362, 363, 465, 467, 230, 466, 468, 256, 230, - 502, 469, 355, 470, 255, 257, 402, 219, 495, 497, - 375, 523, 527, 536, 474, 537, 254, 498, 511, 314, - 313, 522, 241, 339, 291, 535, 0, 291, 0, 0, + 216, 237, 244, 365, 200, 374, 202, 260, 449, 252, + 495, 419, 314, 450, 413, 452, 228, 404, 454, 513, + 270, 391, 392, 393, 394, 246, 244, 225, 268, 237, + 246, 538, 362, 383, 513, 541, 317, 269, 223, 246, + 541, 316, 318, 375, 376, 361, 363, 259, 271, 328, + 224, 272, 405, 323, 273, 427, 229, 429, 395, 396, + 455, 226, -29, 316, 377, 316, 230, 320, 378, 380, + 367, 457, 451, 321, 510, 381, 488, 446, 511, 389, + 446, 390, 408, 232, 446, 410, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 365, 459, 365, 419, + 544, 365, 498, 467, 468, 444, 446, 469, 470, 471, + 472, 239, 244, 233, 240, 461, 548, 370, 323, 446, + 371, 323, 447, 486, 446, 486, 487, 491, 504, 196, + 197, 198, 397, 398, 386, 387, 388, 499, 241, 500, + 250, 419, 446, 493, 490, 446, 519, 246, 492, 449, + 256, 518, 465, 466, 473, 474, 261, 266, 267, 316, + 319, 369, 253, 327, 323, 379, 384, 402, 403, 401, + 399, 400, 409, 406, 415, 420, 423, 421, 424, 496, + 497, 425, 428, 430, 456, 365, 431, 460, 432, -28, + 506, 550, 446, 301, 485, -23, 482, 520, 502, 529, + -378, 503, 449, 530, 531, 238, 535, 536, 534, 323, + 340, 539, 540, 245, 512, 552, 475, 477, 551, 480, + 216, 476, 264, 263, 200, 478, 202, 258, 265, 512, + 372, 373, 227, 238, 365, 479, 484, 238, 412, 505, + 533, 507, 537, 546, 262, 547, 521, 508, 249, 385, + 0, 323, 0, 532, 545, 0, 0, 324, 0, 0, + 0, 349, 0, 301, 0, 0, 301, 0, 0, 0, + 0, 0, 0, 0, 365, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 355, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 504, + 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 244, 0, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 236, 0, 0, 0, 504, 0, 0, 0, 0, 0, - 0, 0, 314, 404, 0, 314, 0, 0, 0, 0, - 0, 0, 0, 0, 452, 453, 454, 291, 291, 291, - 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, - 291, 291, 291, 0, 339, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 314, 0, + 0, 0, 324, 414, 0, 324, 0, 0, 0, 0, + 0, 0, 0, 462, 463, 464, 301, 301, 301, 301, + 301, 301, 301, 301, 301, 301, 301, 301, 301, 301, + 301, 301, 0, 0, 349, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 324, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 314, 0, 0, 0, 0, 0, 0, - 0, 0, 339, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 339, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 324, 0, 0, 0, 0, 0, 0, + 0, 0, 349, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 349, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 314, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 324, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 339, - 0, 0, 0, 0, 339, 339, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 339, - 0, 0, 0, 0, 237, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 339, 0, 0, 0, - 339, 0, 0, 0, 0, 339, 0, 240, 0, 339, - 1, 2, 3, 4, 5, 6, 7, 8, 339, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, - 10, 11, 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, 0, 0, 185, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 349, + 0, 0, 0, 0, 349, 349, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 349, + 0, 0, 0, 0, 245, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 349, 0, 0, 0, + 349, 0, 0, 0, 0, 349, 0, 0, 0, 349, + 0, 0, 0, 0, 0, 0, 248, 0, 349, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 186, 187, - 188, 189, 190, 191, 1, 2, 3, 4, 5, 6, - 7, 8, 319, 320, 321, 0, 322, 323, 324, 325, - 326, 327, 328, 9, 10, 11, 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, 329, - 267, 185, 268, 269, 270, 271, 272, 0, 0, 273, - 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 275, 0, - 0, 0, 330, 331, 0, 0, 0, 0, 332, 277, - 278, 279, 280, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 186, 187, 188, 189, 190, 191, 1, 2, - 3, 4, 5, 6, 7, 8, 319, 320, 321, 0, - 322, 323, 324, 325, 326, 327, 328, 9, 10, 11, - 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, 329, 267, 185, 268, 269, 270, 271, - 272, 0, 0, 273, 274, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 275, 0, 0, 0, 330, 438, 0, 0, - 0, 0, 332, 277, 278, 279, 280, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 186, 187, 188, 189, - 190, 191, 1, 2, 3, 4, 5, 6, 7, 8, - 319, 320, 321, 0, 322, 323, 324, 325, 326, 327, - 328, 9, 10, 11, 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, 329, 267, 185, - 268, 269, 270, 271, 272, 0, 0, 273, 274, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 275, 0, 0, 0, - 330, 0, 0, 0, 0, 0, 332, 277, 278, 279, - 280, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 186, 187, 188, 189, 190, 191, 1, 2, 3, 4, - 5, 6, 7, 8, 319, 320, 321, 0, 322, 323, - 324, 325, 326, 327, 328, 9, 10, 11, 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, 329, 267, 185, 268, 269, 270, 271, 272, 0, - 0, 273, 274, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 275, 0, 0, 0, 253, 0, 0, 0, 0, 0, - 332, 277, 278, 279, 280, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 186, 187, 188, 189, 190, 191, - 1, 2, 3, 4, 5, 6, 7, 8, 319, 320, - 321, 0, 322, 323, 324, 325, 326, 327, 328, 9, - 10, 11, 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, 329, 267, 185, 268, 269, - 270, 271, 272, 0, 0, 273, 274, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 275, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 332, 277, 278, 279, 280, 1, - 2, 3, 4, 5, 6, 7, 8, 0, 186, 187, - 188, 189, 190, 191, 0, 0, 0, 0, 9, 10, 11, 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, @@ -1574,37 +1448,16 @@ static const yytype_int16 yytable[] = 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, 0, 267, 185, 268, 269, 270, - 271, 272, 0, 0, 273, 274, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 275, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 332, 277, 278, 279, 280, 1, 2, - 3, 4, 5, 6, 7, 8, 0, 186, 187, 188, - 189, 190, 191, 0, 0, 0, 0, 9, 10, 11, - 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, 0, 0, 185, 0, 0, 0, 0, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 0, 0, 193, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 186, 187, 188, 189, - 190, 191, 9, 10, 11, 12, 13, 14, 15, 16, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 194, 195, 196, + 197, 198, 199, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 329, 330, 331, 0, 332, 333, 334, + 335, 336, 337, 338, 11, 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, @@ -1621,37 +1474,16 @@ static const yytype_int16 yytable[] = 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, 0, 267, - 185, 268, 269, 270, 271, 272, 0, 0, 273, 274, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 339, 275, 193, 276, + 277, 278, 279, 280, 281, 282, 0, 0, 283, 284, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 275, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 277, 278, - 279, 280, 1, 2, 3, 4, 5, 6, 7, 8, - 0, 186, 187, 188, 189, 190, 0, 0, 0, 0, - 0, 9, 10, 11, 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, 0, 234, 185, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 235, 1, 2, 3, - 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, - 186, 187, 188, 189, 190, 0, 9, 10, 11, 12, + 0, 0, 0, 0, 0, 0, 0, 285, 0, 0, + 0, 340, 341, 0, 0, 0, 0, 342, 287, 288, + 289, 290, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 194, 195, 196, 197, 198, 199, 1, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 329, 330, 331, + 0, 332, 333, 334, 335, 336, 337, 338, 11, 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, @@ -1669,344 +1501,16 @@ static const yytype_int16 yytable[] = 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, 0, 0, 185, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 408, 0, 0, 0, - 0, 1, 2, 3, 4, 5, 6, 7, 8, 0, - 0, 0, 0, 0, 0, 186, 187, 188, 189, 190, - 9, 10, 11, 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, 0, 0, 185, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 473, 0, 0, 0, 0, 1, 2, 3, 4, 5, - 6, 7, 8, 0, 0, 0, 0, 0, 0, 186, - 187, 188, 189, 190, 9, 10, 11, 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, - 0, 0, 185, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 491, 0, 0, 0, 0, 1, - 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, - 0, 0, 0, 186, 187, 188, 189, 190, 9, 10, - 11, 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, 0, 0, 185, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 4, 5, 6, 7, - 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 186, 187, 188, - 189, 190, 39, 40, 41, 42, 43, 44, 0, 0, - 0, 0, 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, 0, 267, - 185, 268, 269, 270, 271, 272, 0, 0, 273, 274, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 275, 0, 0, - 0, 354, 507, 4, 5, 6, 7, 8, 277, 278, - 279, 280, 0, 0, 0, 0, 0, 0, 0, 0, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 39, - 40, 41, 42, 43, 44, 0, 0, 0, 0, 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, 0, 267, 185, 268, 269, - 270, 271, 272, 0, 0, 273, 274, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 275, 0, 0, 276, 4, 5, - 6, 7, 8, 0, 0, 277, 278, 279, 280, 0, - 0, 0, 0, 0, 0, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 39, 40, 41, 42, 43, 44, - 0, 0, 0, 0, 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, - 0, 267, 185, 268, 269, 270, 271, 272, 0, 0, - 273, 274, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 275, - 0, 0, 0, 354, 4, 5, 6, 7, 8, 0, - 277, 278, 279, 280, 0, 0, 0, 0, 0, 0, - 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 39, 40, 41, 42, 43, 44, 0, 0, 0, 0, - 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, 0, 267, 185, 268, - 269, 270, 271, 272, 0, 0, 273, 274, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 275, 0, 0, 397, 4, - 5, 6, 7, 8, 0, 0, 277, 278, 279, 280, - 0, 0, 0, 0, 0, 0, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 39, 40, 41, 42, 43, - 44, 0, 0, 0, 0, 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, 0, 267, 185, 268, 269, 270, 271, 272, 0, - 0, 273, 274, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 275, 4, 5, 6, 7, 8, 0, 0, 0, 0, - 416, 277, 278, 279, 280, 0, 0, 0, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 39, 40, 41, - 42, 43, 44, 0, 0, 0, 0, 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, 0, 267, 185, 268, 269, 270, 271, - 272, 0, 0, 273, 274, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 275, 4, 5, 6, 7, 8, 0, 0, - 0, 0, 0, 277, 278, 279, 280, 0, 0, 0, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 39, - 40, 41, 42, 43, 44, 0, 0, 0, 0, 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, 372, 0, 267, 185, 268, 269, - 270, 271, 272, 0, 0, 273, 274, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 275, 4, 5, 6, 7, 8, - 0, 0, 0, 0, 0, 277, 278, 279, 280, 0, - 0, 0, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 39, 40, 41, 42, 43, 44, 0, 0, 0, - 0, 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, 0, 0, 185 -}; - -#define yypact_value_is_default(Yystate) \ - (!!((Yystate) == (-466))) - -#define yytable_value_is_error(Yytable_value) \ - YYID (0) - -static const yytype_int16 yycheck[] = -{ - 0, 205, 197, 261, 0, 0, 275, 344, 220, 46, - 423, 238, 352, 199, 354, 312, 315, 357, 215, 484, - 199, 233, 227, 208, 209, 229, 228, 210, 211, 229, - 225, 289, 234, 229, 499, 227, 227, 237, 229, 237, - 234, 237, 227, 237, 229, 236, 258, 259, 233, 206, - 207, 237, 231, 250, 249, 228, 325, 234, 327, 234, - 237, 358, 245, 246, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 229, 412, 516, 229, 199, 306, - 520, 236, 309, 236, 236, 525, 229, 234, 229, 231, - 237, 228, 234, 236, 352, 237, 354, 234, 367, 357, - 228, 441, 228, 200, 403, 228, 234, 234, 234, 313, - 237, 234, 228, 371, 231, 228, 529, 312, 234, 231, - 315, 234, 383, 384, 385, 386, 234, 234, 199, 237, - 237, 253, 254, 255, 212, 213, 242, 243, 244, 239, - 232, 241, 234, 234, 235, 414, 445, 229, 485, 418, - 490, 234, 235, 379, 380, 199, 381, 382, 387, 388, - 236, 199, 199, 358, 237, 228, 227, 247, 249, 248, - 216, 214, 230, 200, 199, 237, 227, 435, 436, 227, - 237, 237, 227, 441, 199, 235, 238, 227, 227, 199, - 530, 232, 228, 405, 198, 230, 230, 197, 227, 231, - 199, 538, 471, 234, 228, 205, 232, 237, 403, 228, - 14, 231, 212, 231, 236, 484, 212, 212, 232, 219, - 237, 273, 274, 389, 391, 225, 390, 392, 229, 229, - 499, 393, 490, 394, 225, 229, 311, 191, 476, 479, - 292, 510, 515, 525, 404, 526, 223, 479, 499, 249, - 445, 509, 212, 253, 306, 524, -1, 309, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 530, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 484, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 504, -1, -1, -1, 499, -1, -1, -1, -1, -1, - -1, -1, 312, 313, -1, 315, -1, -1, -1, -1, - -1, -1, -1, -1, 376, 377, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, -1, 344, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 358, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 403, -1, -1, -1, -1, -1, -1, - -1, -1, 412, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 423, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 445, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 479, - -1, -1, -1, -1, 484, 485, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 499, - -1, -1, -1, -1, 504, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 516, -1, -1, -1, - 520, -1, -1, -1, -1, 525, -1, 0, -1, 529, - 3, 4, 5, 6, 7, 8, 9, 10, 538, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 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, -1, -1, 200, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 251, 252, - 253, 254, 255, 256, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, -1, 15, 16, 17, 18, + 339, 275, 193, 276, 277, 278, 279, 280, 281, 282, + 0, 0, 283, 284, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 285, 0, 0, 0, 340, 448, 0, 0, 0, + 0, 342, 287, 288, 289, 290, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 194, 195, 196, 197, 198, + 199, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 329, 330, 331, 0, 332, 333, 334, 335, 336, + 337, 338, 11, 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, @@ -2024,14 +1528,15 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 208, - 209, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 227, -1, - -1, -1, 231, 232, -1, -1, -1, -1, 237, 238, - 239, 240, 241, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 251, 252, 253, 254, 255, 256, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, -1, + 189, 190, 191, 192, 339, 275, 193, 276, 277, 278, + 279, 280, 281, 282, 0, 0, 283, 284, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 285, 0, 0, 0, 340, + 0, 0, 0, 0, 0, 342, 287, 288, 289, 290, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 194, + 195, 196, 197, 198, 199, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 329, 330, 331, 0, 332, + 333, 334, 335, 336, 337, 338, 11, 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, @@ -2049,67 +1554,773 @@ static const yytype_int16 yycheck[] = 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, 339, 275, + 193, 276, 277, 278, 279, 280, 281, 282, 0, 0, + 283, 284, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 285, + 0, 0, 0, 261, 0, 0, 0, 0, 0, 342, + 287, 288, 289, 290, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 194, 195, 196, 197, 198, 199, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 329, + 330, 331, 0, 332, 333, 334, 335, 336, 337, 338, + 11, 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, 339, 275, 193, 276, 277, 278, 279, 280, + 281, 282, 0, 0, 283, 284, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 285, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 342, 287, 288, 289, 290, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 194, 195, 196, + 197, 198, 199, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 11, 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, 0, 275, 193, 276, + 277, 278, 279, 280, 281, 282, 0, 0, 283, 284, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 285, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 342, 287, 288, + 289, 290, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 194, 195, 196, 197, 198, 199, 1, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 11, 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, + 0, 0, 193, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 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, + 0, 0, 0, 0, 0, 194, 195, 196, 197, 198, + 199, 11, 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, 0, 275, 193, 276, 277, 278, 279, + 280, 281, 282, 0, 0, 283, 284, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 285, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 287, 288, 289, 290, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 194, 195, + 196, 197, 198, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 11, 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, 0, 242, 193, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 243, 1, 2, + 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, + 0, 194, 195, 196, 197, 198, 0, 0, 0, 11, + 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, 0, 0, 193, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 418, 0, 0, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 0, 0, 0, 0, 0, 0, 194, 195, 196, 197, + 198, 11, 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, 0, 0, 193, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 483, + 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 0, 0, 0, 0, 0, 0, 194, 195, + 196, 197, 198, 11, 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, 0, 0, 193, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 501, 0, 0, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 0, 0, 0, 0, 0, 0, + 194, 195, 196, 197, 198, 11, 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, 0, 0, 193, + 0, 0, 0, 4, 5, 6, 7, 8, 9, 10, + 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 194, 195, 196, 197, 198, 47, 48, 49, + 50, 51, 52, 0, 0, 0, 0, 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, 0, 275, 193, 276, 277, 278, 279, + 280, 281, 282, 0, 0, 283, 284, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 285, 0, 0, 0, 364, 517, + 0, 0, 0, 0, 0, 287, 288, 289, 290, 4, + 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, + 0, 0, 0, 0, 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, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 47, 48, 49, 50, 51, 52, 0, + 0, 0, 0, 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, 0, + 275, 193, 276, 277, 278, 279, 280, 281, 282, 0, + 0, 283, 284, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 285, 0, 0, 286, 4, 5, 6, 7, 8, 9, + 10, 287, 288, 289, 290, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 47, 48, + 49, 50, 51, 52, 0, 0, 0, 0, 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, 0, 275, 193, 276, 277, 278, + 279, 280, 281, 282, 0, 0, 283, 284, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 285, 0, 0, 0, 364, + 0, 0, 0, 0, 0, 0, 287, 288, 289, 290, + 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 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, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 47, 48, 49, 50, 51, 52, + 0, 0, 0, 0, 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, + 0, 275, 193, 276, 277, 278, 279, 280, 281, 282, + 0, 0, 283, 284, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 285, 0, 0, 407, 4, 5, 6, 7, 8, + 9, 10, 287, 288, 289, 290, 0, 0, 0, 0, + 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, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 47, + 48, 49, 50, 51, 52, 0, 0, 0, 0, 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, 0, 275, 193, 276, 277, + 278, 279, 280, 281, 282, 0, 0, 283, 284, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 285, 4, 5, 6, + 7, 8, 9, 10, 0, 0, 426, 287, 288, 289, + 290, 0, 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, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 47, 48, 49, 50, 51, 52, 0, 0, 0, + 0, 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, 0, 275, 193, + 276, 277, 278, 279, 280, 281, 282, 0, 0, 283, + 284, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 285, 4, + 5, 6, 7, 8, 9, 10, 0, 0, 0, 287, + 288, 289, 290, 0, 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, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 47, 48, 49, 50, 51, 52, 0, + 0, 0, 0, 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, 382, 0, + 275, 193, 276, 277, 278, 279, 280, 281, 282, 0, + 0, 283, 284, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 285, 4, 5, 6, 7, 8, 9, 10, 0, 0, + 0, 287, 288, 289, 290, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 47, 48, 49, 50, 51, + 52, 0, 0, 0, 0, 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, 0, 0, 193 +}; + +#define yypact_value_is_default(Yystate) \ + (!!((Yystate) == (-496))) + +#define yytable_value_is_error(Yytable_value) \ + YYID (0) + +static const yytype_int16 yycheck[] = +{ + 0, 205, 213, 269, 0, 285, 0, 228, 354, 54, + 433, 325, 246, 362, 322, 364, 207, 225, 367, 494, + 241, 216, 217, 220, 221, 239, 237, 207, 237, 233, + 239, 526, 246, 299, 509, 530, 238, 246, 237, 239, + 535, 239, 244, 218, 219, 266, 267, 247, 241, 247, + 237, 244, 260, 257, 247, 335, 247, 337, 255, 256, + 368, 241, 237, 239, 239, 239, 247, 238, 243, 238, + 246, 238, 246, 244, 238, 244, 422, 244, 238, 249, + 244, 251, 316, 238, 244, 319, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 362, 377, 364, 413, + 238, 367, 451, 391, 392, 246, 244, 393, 394, 395, + 396, 244, 323, 244, 247, 381, 539, 244, 322, 244, + 247, 325, 247, 244, 244, 244, 247, 247, 247, 263, + 264, 265, 222, 223, 252, 253, 254, 242, 207, 244, + 208, 455, 244, 245, 424, 244, 245, 239, 428, 495, + 241, 500, 389, 390, 397, 398, 241, 207, 207, 239, + 246, 207, 207, 247, 368, 238, 237, 224, 226, 257, + 259, 258, 208, 240, 207, 247, 237, 247, 237, 445, + 446, 247, 237, 245, 207, 451, 237, 207, 242, 237, + 206, 540, 244, 246, 415, 238, 240, 237, 240, 207, + 241, 481, 548, 238, 242, 205, 238, 16, 247, 413, + 241, 241, 246, 213, 494, 242, 399, 401, 247, 404, + 220, 400, 237, 233, 220, 402, 220, 227, 237, 509, + 283, 284, 199, 233, 500, 403, 414, 237, 321, 486, + 520, 489, 525, 535, 231, 536, 509, 489, 220, 302, + -1, 455, -1, 519, 534, -1, -1, 257, -1, -1, + -1, 261, -1, 316, -1, -1, 319, -1, -1, -1, + -1, -1, -1, -1, 540, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 494, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 514, -1, 509, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 322, 323, -1, 325, -1, -1, -1, -1, + -1, -1, -1, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, -1, -1, 354, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 368, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 413, -1, -1, -1, -1, -1, -1, + -1, -1, 422, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 433, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 455, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 489, + -1, -1, -1, -1, 494, 495, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 509, + -1, -1, -1, -1, 514, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 526, -1, -1, -1, + 530, -1, -1, -1, -1, 535, -1, -1, -1, 539, + -1, -1, -1, -1, -1, -1, 0, -1, 548, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 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, -1, -1, 208, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 261, 262, 263, + 264, 265, 266, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, -1, 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, -1, -1, 218, 219, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 237, -1, -1, + -1, 241, 242, -1, -1, -1, -1, 247, 248, 249, + 250, 251, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 261, 262, 263, 264, 265, 266, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + -1, 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, + -1, -1, 218, 219, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 237, -1, -1, -1, 241, 242, -1, -1, -1, + -1, 247, 248, 249, 250, 251, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 261, 262, 263, 264, 265, + 266, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, -1, 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, -1, -1, 218, 219, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 237, -1, -1, -1, 241, + -1, -1, -1, -1, -1, 247, 248, 249, 250, 251, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 261, + 262, 263, 264, 265, 266, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, -1, 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, -1, -1, + 218, 219, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 237, + -1, -1, -1, 241, -1, -1, -1, -1, -1, 247, + 248, 249, 250, 251, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 261, 262, 263, 264, 265, 266, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, -1, 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, -1, -1, 218, 219, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 237, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 247, 248, 249, 250, 251, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 261, 262, 263, + 264, 265, 266, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 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, -1, 207, 208, 209, + 210, 211, 212, 213, 214, 215, -1, -1, 218, 219, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 237, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 247, 248, 249, + 250, 251, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 261, 262, 263, 264, 265, 266, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 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, + -1, -1, 208, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -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, + -1, -1, -1, -1, -1, 261, 262, 263, 264, 265, + 266, 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, -1, 207, 208, 209, 210, 211, 212, + 213, 214, 215, -1, -1, 218, 219, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 237, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 248, 249, 250, 251, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 261, 262, + 263, 264, 265, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 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, -1, 207, 208, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 247, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, -1, -1, + -1, 261, 262, 263, 264, 265, -1, -1, -1, 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, -1, -1, 208, 209, -1, -1, -1, -1, -1, + 205, -1, -1, 208, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 227, -1, -1, -1, 231, 232, -1, -1, - -1, -1, 237, 238, 239, 240, 241, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 251, 252, 253, 254, - 255, 256, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, -1, 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, -1, -1, 208, 209, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 227, -1, -1, -1, - 231, -1, -1, -1, -1, -1, 237, 238, 239, 240, - 241, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 251, 252, 253, 254, 255, 256, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, -1, 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, -1, - -1, 208, 209, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 227, -1, -1, -1, 231, -1, -1, -1, -1, -1, - 237, 238, 239, 240, 241, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 251, 252, 253, 254, 255, 256, + -1, -1, -1, -1, -1, -1, -1, 242, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, -1, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + -1, -1, -1, -1, -1, -1, 261, 262, 263, 264, + 265, 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, @@ -2127,84 +2338,13 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 208, 209, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 227, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 237, 238, 239, 240, 241, 3, - 4, 5, 6, 7, 8, 9, 10, -1, 251, 252, - 253, 254, 255, 256, -1, -1, -1, -1, 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, -1, 199, 200, 201, 202, 203, - 204, 205, -1, -1, 208, 209, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 227, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 237, 238, 239, 240, 241, 3, 4, - 5, 6, 7, 8, 9, 10, -1, 251, 252, 253, - 254, 255, 256, -1, -1, -1, -1, 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, -1, -1, 200, -1, -1, -1, -1, + 203, 204, 205, -1, -1, 208, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -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, -1, -1, -1, -1, -1, 251, 252, 253, 254, - 255, 256, 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, -1, 199, - 200, 201, 202, 203, 204, 205, -1, -1, 208, 209, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 227, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 238, 239, - 240, 241, 3, 4, 5, 6, 7, 8, 9, 10, - -1, 251, 252, 253, 254, 255, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 242, + -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, -1, -1, -1, -1, -1, -1, 261, 262, + 263, 264, 265, 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, @@ -2221,131 +2361,39 @@ static const yytype_int16 yycheck[] = 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, -1, 199, 200, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, -1, -1, 208, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 237, 3, 4, 5, - 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, - 251, 252, 253, 254, 255, -1, 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, -1, -1, 200, -1, -1, -1, -1, -1, + -1, 242, -1, -1, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, -1, -1, -1, -1, -1, -1, + 261, 262, 263, 264, 265, 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, -1, -1, 208, + -1, -1, -1, 6, 7, 8, 9, 10, 11, 12, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 232, -1, -1, -1, - -1, 3, 4, 5, 6, 7, 8, 9, 10, -1, - -1, -1, -1, -1, -1, 251, 252, 253, 254, 255, - 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, -1, -1, 200, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 232, -1, -1, -1, -1, 3, 4, 5, 6, 7, - 8, 9, 10, -1, -1, -1, -1, -1, -1, 251, - 252, 253, 254, 255, 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, - -1, -1, 200, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 232, -1, -1, -1, -1, 3, - 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, - -1, -1, -1, 251, 252, 253, 254, 255, 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, -1, -1, 200, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 6, 7, 8, 9, - 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 251, 252, 253, - 254, 255, 52, 53, 54, 55, 56, 57, -1, -1, - -1, -1, 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, -1, 199, - 200, 201, 202, 203, 204, 205, -1, -1, 208, 209, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 227, -1, -1, - -1, 231, 232, 6, 7, 8, 9, 10, 238, 239, - 240, 241, -1, -1, -1, -1, -1, -1, -1, -1, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 52, - 53, 54, 55, 56, 57, -1, -1, -1, -1, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + -1, -1, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 261, 262, 263, 264, 265, 60, 61, 62, + 63, 64, 65, -1, -1, -1, -1, 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, @@ -2358,62 +2406,19 @@ static const yytype_int16 yycheck[] = 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, -1, 199, 200, 201, 202, - 203, 204, 205, -1, -1, 208, 209, -1, -1, -1, + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, -1, 207, 208, 209, 210, 211, 212, + 213, 214, 215, -1, -1, 218, 219, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 227, -1, -1, 230, 6, 7, - 8, 9, 10, -1, -1, 238, 239, 240, 241, -1, - -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 52, 53, 54, 55, 56, 57, - -1, -1, -1, -1, 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, - -1, 199, 200, 201, 202, 203, 204, 205, -1, -1, - 208, 209, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 227, - -1, -1, -1, 231, 6, 7, 8, 9, 10, -1, - 238, 239, 240, 241, -1, -1, -1, -1, -1, -1, - -1, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 52, 53, 54, 55, 56, 57, -1, -1, -1, -1, - 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, -1, 199, 200, 201, - 202, 203, 204, 205, -1, -1, 208, 209, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 227, -1, -1, 230, 6, - 7, 8, 9, 10, -1, -1, 238, 239, 240, 241, - -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, + -1, -1, -1, -1, 237, -1, -1, -1, 241, 242, + -1, -1, -1, -1, -1, 248, 249, 250, 251, 6, + 7, 8, 9, 10, 11, 12, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 52, 53, 54, 55, 56, - 57, -1, -1, -1, -1, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 37, 38, 39, 40, 41, 42, 43, 44, 45, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 60, 61, 62, 63, 64, 65, -1, + -1, -1, -1, 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, @@ -2426,60 +2431,65 @@ static const yytype_int16 yycheck[] = 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, -1, 199, 200, 201, 202, 203, 204, 205, -1, - -1, 208, 209, -1, -1, -1, -1, -1, -1, -1, + 197, 198, 199, 200, 201, 202, 203, 204, 205, -1, + 207, 208, 209, 210, 211, 212, 213, 214, 215, -1, + -1, 218, 219, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 227, 6, 7, 8, 9, 10, -1, -1, -1, -1, - 237, 238, 239, 240, 241, -1, -1, -1, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 52, 53, 54, - 55, 56, 57, -1, -1, -1, -1, 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, -1, 199, 200, 201, 202, 203, 204, - 205, -1, -1, 208, 209, -1, -1, -1, -1, -1, + 237, -1, -1, 240, 6, 7, 8, 9, 10, 11, + 12, 248, 249, 250, 251, -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, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 60, 61, + 62, 63, 64, 65, -1, -1, -1, -1, 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, -1, 207, 208, 209, 210, 211, + 212, 213, 214, 215, -1, -1, 218, 219, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 227, 6, 7, 8, 9, 10, -1, -1, - -1, -1, -1, 238, 239, 240, 241, -1, -1, -1, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 52, - 53, 54, 55, 56, 57, -1, -1, -1, -1, 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, -1, 199, 200, 201, 202, - 203, 204, 205, -1, -1, 208, 209, -1, -1, -1, + -1, -1, -1, -1, -1, 237, -1, -1, -1, 241, + -1, -1, -1, -1, -1, -1, 248, 249, 250, 251, + 6, 7, 8, 9, 10, 11, 12, -1, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 227, 6, 7, 8, 9, 10, - -1, -1, -1, -1, -1, 238, 239, 240, 241, -1, - -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, -1, -1, -1, + -1, -1, -1, -1, 60, 61, 62, 63, 64, 65, + -1, -1, -1, -1, 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, + -1, 207, 208, 209, 210, 211, 212, 213, 214, 215, + -1, -1, 218, 219, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 52, 53, 54, 55, 56, 57, -1, -1, -1, - -1, 62, 63, 64, 65, 66, 67, 68, 69, 70, + -1, 237, -1, -1, 240, 6, 7, 8, 9, 10, + 11, 12, 248, 249, 250, 251, -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, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 60, + 61, 62, 63, 64, 65, -1, -1, -1, -1, 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, @@ -2492,15 +2502,86 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 200 + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, -1, 207, 208, 209, 210, + 211, 212, 213, 214, 215, -1, -1, 218, 219, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 237, 6, 7, 8, + 9, 10, 11, 12, -1, -1, 247, 248, 249, 250, + 251, -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, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 60, 61, 62, 63, 64, 65, -1, -1, -1, + -1, 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, -1, 207, 208, + 209, 210, 211, 212, 213, 214, 215, -1, -1, 218, + 219, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 237, 6, + 7, 8, 9, 10, 11, 12, -1, -1, -1, 248, + 249, 250, 251, -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, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 60, 61, 62, 63, 64, 65, -1, + -1, -1, -1, 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, -1, + 207, 208, 209, 210, 211, 212, 213, 214, 215, -1, + -1, 218, 219, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 237, 6, 7, 8, 9, 10, 11, 12, -1, -1, + -1, 248, 249, 250, 251, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 60, 61, 62, 63, 64, + 65, -1, -1, -1, -1, 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, -1, -1, 208 }; /* 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, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 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, @@ -2517,43 +2598,44 @@ static const yytype_uint16 yystos[] = 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, 200, 251, 252, 253, 254, - 255, 256, 291, 292, 295, 296, 297, 298, 302, 303, - 304, 305, 306, 307, 310, 311, 312, 313, 315, 317, - 318, 319, 356, 357, 358, 227, 227, 199, 231, 318, - 199, 237, 237, 359, 228, 234, 299, 300, 301, 311, - 315, 234, 237, 199, 199, 237, 312, 315, 229, 316, - 0, 357, 200, 314, 46, 199, 308, 309, 231, 321, - 315, 237, 316, 231, 338, 300, 299, 301, 199, 199, - 227, 236, 316, 231, 234, 237, 294, 199, 201, 202, - 203, 204, 205, 208, 209, 227, 230, 238, 239, 240, - 241, 261, 262, 263, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 315, 229, 228, 234, 236, - 228, 234, 320, 311, 315, 322, 323, 237, 237, 11, - 12, 13, 15, 16, 17, 18, 19, 20, 21, 198, - 231, 232, 237, 272, 285, 287, 289, 291, 295, 315, - 328, 329, 330, 331, 339, 340, 341, 344, 347, 348, - 355, 316, 236, 316, 231, 287, 326, 236, 293, 199, - 234, 237, 272, 272, 289, 208, 209, 229, 233, 228, - 228, 234, 197, 287, 227, 272, 242, 243, 244, 239, - 241, 206, 207, 210, 211, 245, 246, 212, 213, 249, - 248, 247, 214, 216, 215, 250, 230, 230, 285, 200, - 285, 290, 309, 322, 315, 199, 324, 325, 232, 323, - 237, 237, 350, 227, 227, 237, 237, 289, 227, 289, - 235, 227, 232, 332, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 236, 288, 234, 237, 232, 329, - 326, 236, 326, 327, 326, 322, 199, 228, 264, 289, - 199, 287, 272, 272, 272, 274, 274, 275, 275, 276, - 276, 276, 276, 277, 277, 278, 279, 280, 281, 282, - 283, 286, 230, 232, 324, 316, 234, 237, 329, 351, - 289, 237, 289, 235, 349, 339, 287, 287, 326, 232, - 234, 232, 230, 289, 237, 325, 198, 328, 340, 352, - 228, 228, 289, 304, 311, 343, 333, 232, 326, 235, - 227, 343, 353, 354, 335, 336, 337, 342, 345, 199, - 228, 232, 287, 289, 237, 228, 14, 331, 330, 231, - 236, 330, 334, 338, 228, 289, 334, 335, 339, 346, - 326, 237, 232 + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 208, 261, 262, 263, 264, 265, 266, + 301, 302, 305, 306, 307, 308, 312, 313, 314, 315, + 316, 317, 320, 321, 322, 323, 325, 327, 328, 329, + 366, 367, 368, 237, 237, 207, 241, 328, 207, 247, + 247, 369, 238, 244, 309, 310, 311, 321, 325, 244, + 247, 207, 207, 247, 322, 325, 239, 326, 0, 367, + 208, 324, 54, 207, 318, 319, 241, 331, 325, 247, + 326, 241, 348, 310, 309, 311, 207, 207, 237, 246, + 326, 241, 244, 247, 304, 207, 209, 210, 211, 212, + 213, 214, 215, 218, 219, 237, 240, 248, 249, 250, + 251, 271, 272, 273, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 325, 239, 238, 244, 246, + 238, 244, 330, 321, 325, 332, 333, 247, 247, 13, + 14, 15, 17, 18, 19, 20, 21, 22, 23, 206, + 241, 242, 247, 282, 295, 297, 299, 301, 305, 325, + 338, 339, 340, 341, 349, 350, 351, 354, 357, 358, + 365, 326, 246, 326, 241, 297, 336, 246, 303, 207, + 244, 247, 282, 282, 299, 218, 219, 239, 243, 238, + 238, 244, 205, 297, 237, 282, 252, 253, 254, 249, + 251, 216, 217, 220, 221, 255, 256, 222, 223, 259, + 258, 257, 224, 226, 225, 260, 240, 240, 295, 208, + 295, 300, 319, 332, 325, 207, 334, 335, 242, 333, + 247, 247, 360, 237, 237, 247, 247, 299, 237, 299, + 245, 237, 242, 342, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 246, 298, 244, 247, 242, 339, + 336, 246, 336, 337, 336, 332, 207, 238, 274, 299, + 207, 297, 282, 282, 282, 284, 284, 285, 285, 286, + 286, 286, 286, 287, 287, 288, 289, 290, 291, 292, + 293, 296, 240, 242, 334, 326, 244, 247, 339, 361, + 299, 247, 299, 245, 359, 349, 297, 297, 336, 242, + 244, 242, 240, 299, 247, 335, 206, 338, 350, 362, + 238, 238, 299, 314, 321, 353, 343, 242, 336, 245, + 237, 353, 363, 364, 345, 346, 347, 352, 355, 207, + 238, 242, 297, 299, 247, 238, 16, 341, 340, 241, + 246, 340, 344, 348, 238, 299, 344, 345, 349, 356, + 336, 247, 242 }; #define yyerrok (yyerrstatus = 0) @@ -3374,7 +3456,7 @@ yyreduce: { case 2: /* Line 1792 of yacc.c */ -#line 244 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 246 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[(1) - (1)].lex).loc, (yyvsp[(1) - (1)].lex).symbol, (yyvsp[(1) - (1)].lex).string); } @@ -3382,7 +3464,7 @@ yyreduce: case 3: /* Line 1792 of yacc.c */ -#line 250 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 252 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } @@ -3390,7 +3472,7 @@ yyreduce: case 4: /* Line 1792 of yacc.c */ -#line 253 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 255 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).i, (yyvsp[(1) - (1)].lex).loc, true); } @@ -3398,7 +3480,7 @@ yyreduce: case 5: /* Line 1792 of yacc.c */ -#line 256 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 258 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "unsigned literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).u, (yyvsp[(1) - (1)].lex).loc, true); @@ -3407,32 +3489,50 @@ yyreduce: case 6: /* Line 1792 of yacc.c */ -#line 260 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 262 "glslang.y" { - (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).d, EbtFloat, (yyvsp[(1) - (1)].lex).loc, true); + parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit integer literal"); + (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).i64, (yyvsp[(1) - (1)].lex).loc, true); } break; case 7: /* Line 1792 of yacc.c */ -#line 263 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 266 "glslang.y" + { + parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit unsigned integer literal"); + (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).u64, (yyvsp[(1) - (1)].lex).loc, true); + } + break; + + case 8: +/* Line 1792 of yacc.c */ +#line 270 "glslang.y" + { + (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).d, EbtFloat, (yyvsp[(1) - (1)].lex).loc, true); + } + break; + + case 9: +/* Line 1792 of yacc.c */ +#line 273 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).d, EbtDouble, (yyvsp[(1) - (1)].lex).loc, true); } break; - case 8: + case 10: /* Line 1792 of yacc.c */ -#line 267 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 277 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).b, (yyvsp[(1) - (1)].lex).loc, true); } break; - case 9: + case 11: /* Line 1792 of yacc.c */ -#line 270 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 280 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(2) - (3)].interm.intermTypedNode); if ((yyval.interm.intermTypedNode)->getAsConstantUnion()) @@ -3440,25 +3540,9 @@ yyreduce: } break; - case 10: -/* Line 1792 of yacc.c */ -#line 278 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); - } - break; - - case 11: -/* Line 1792 of yacc.c */ -#line 281 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[(2) - (4)].lex).loc, (yyvsp[(1) - (4)].interm.intermTypedNode), (yyvsp[(3) - (4)].interm.intermTypedNode)); - } - break; - case 12: /* Line 1792 of yacc.c */ -#line 284 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 288 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } @@ -3466,15 +3550,31 @@ yyreduce: case 13: /* Line 1792 of yacc.c */ -#line 287 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 291 "glslang.y" { - (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[(3) - (3)].lex).loc, (yyvsp[(1) - (3)].interm.intermTypedNode), *(yyvsp[(3) - (3)].lex).string); + (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[(2) - (4)].lex).loc, (yyvsp[(1) - (4)].interm.intermTypedNode), (yyvsp[(3) - (4)].interm.intermTypedNode)); } break; case 14: /* Line 1792 of yacc.c */ -#line 290 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 294 "glslang.y" + { + (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); + } + break; + + case 15: +/* Line 1792 of yacc.c */ +#line 297 "glslang.y" + { + (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[(3) - (3)].lex).loc, (yyvsp[(1) - (3)].interm.intermTypedNode), *(yyvsp[(3) - (3)].lex).string); + } + break; + + case 16: +/* Line 1792 of yacc.c */ +#line 300 "glslang.y" { parseContext.variableCheck((yyvsp[(1) - (2)].interm.intermTypedNode)); parseContext.lValueErrorCheck((yyvsp[(2) - (2)].lex).loc, "++", (yyvsp[(1) - (2)].interm.intermTypedNode)); @@ -3482,9 +3582,9 @@ yyreduce: } break; - case 15: + case 17: /* Line 1792 of yacc.c */ -#line 295 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 305 "glslang.y" { parseContext.variableCheck((yyvsp[(1) - (2)].interm.intermTypedNode)); parseContext.lValueErrorCheck((yyvsp[(2) - (2)].lex).loc, "--", (yyvsp[(1) - (2)].interm.intermTypedNode)); @@ -3492,69 +3592,69 @@ yyreduce: } break; - case 16: + case 18: /* Line 1792 of yacc.c */ -#line 303 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 313 "glslang.y" { parseContext.integerCheck((yyvsp[(1) - (1)].interm.intermTypedNode), "[]"); (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 17: + case 19: /* Line 1792 of yacc.c */ -#line 310 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 320 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[(1) - (1)].interm).loc, (yyvsp[(1) - (1)].interm).function, (yyvsp[(1) - (1)].interm).intermNode); delete (yyvsp[(1) - (1)].interm).function; } break; - case 18: -/* Line 1792 of yacc.c */ -#line 317 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm) = (yyvsp[(1) - (1)].interm); - } - break; - - case 19: -/* Line 1792 of yacc.c */ -#line 323 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm) = (yyvsp[(1) - (2)].interm); - (yyval.interm).loc = (yyvsp[(2) - (2)].lex).loc; - } - break; - case 20: /* Line 1792 of yacc.c */ -#line 327 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 327 "glslang.y" { - (yyval.interm) = (yyvsp[(1) - (2)].interm); - (yyval.interm).loc = (yyvsp[(2) - (2)].lex).loc; + (yyval.interm) = (yyvsp[(1) - (1)].interm); } break; case 21: /* Line 1792 of yacc.c */ -#line 334 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 333 "glslang.y" { (yyval.interm) = (yyvsp[(1) - (2)].interm); + (yyval.interm).loc = (yyvsp[(2) - (2)].lex).loc; } break; case 22: /* Line 1792 of yacc.c */ -#line 337 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 337 "glslang.y" { - (yyval.interm) = (yyvsp[(1) - (1)].interm); + (yyval.interm) = (yyvsp[(1) - (2)].interm); + (yyval.interm).loc = (yyvsp[(2) - (2)].lex).loc; } break; case 23: /* Line 1792 of yacc.c */ -#line 343 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 344 "glslang.y" + { + (yyval.interm) = (yyvsp[(1) - (2)].interm); + } + break; + + case 24: +/* Line 1792 of yacc.c */ +#line 347 "glslang.y" + { + (yyval.interm) = (yyvsp[(1) - (1)].interm); + } + break; + + case 25: +/* Line 1792 of yacc.c */ +#line 353 "glslang.y" { TParameter param = { 0, new TType }; param.type->shallowCopy((yyvsp[(2) - (2)].interm.intermTypedNode)->getType()); @@ -3564,9 +3664,9 @@ yyreduce: } break; - case 24: + case 26: /* Line 1792 of yacc.c */ -#line 350 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 360 "glslang.y" { TParameter param = { 0, new TType }; param.type->shallowCopy((yyvsp[(3) - (3)].interm.intermTypedNode)->getType()); @@ -3576,17 +3676,17 @@ yyreduce: } break; - case 25: + case 27: /* Line 1792 of yacc.c */ -#line 360 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 370 "glslang.y" { (yyval.interm) = (yyvsp[(1) - (2)].interm); } break; - case 26: + case 28: /* Line 1792 of yacc.c */ -#line 368 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 378 "glslang.y" { // Constructor (yyval.interm).intermNode = 0; @@ -3594,9 +3694,9 @@ yyreduce: } break; - case 27: + case 29: /* Line 1792 of yacc.c */ -#line 373 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 383 "glslang.y" { // // Should be a method or subroutine call, but we haven't recognized the arguments yet. @@ -3626,9 +3726,9 @@ yyreduce: } break; - case 28: + case 30: /* Line 1792 of yacc.c */ -#line 403 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 413 "glslang.y" { parseContext.variableCheck((yyvsp[(1) - (1)].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); @@ -3637,27 +3737,27 @@ yyreduce: } break; - case 29: + case 31: /* Line 1792 of yacc.c */ -#line 409 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 419 "glslang.y" { parseContext.lValueErrorCheck((yyvsp[(1) - (2)].lex).loc, "++", (yyvsp[(2) - (2)].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[(1) - (2)].lex).loc, "++", EOpPreIncrement, (yyvsp[(2) - (2)].interm.intermTypedNode)); } break; - case 30: + case 32: /* Line 1792 of yacc.c */ -#line 413 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 423 "glslang.y" { parseContext.lValueErrorCheck((yyvsp[(1) - (2)].lex).loc, "--", (yyvsp[(2) - (2)].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[(1) - (2)].lex).loc, "--", EOpPreDecrement, (yyvsp[(2) - (2)].interm.intermTypedNode)); } break; - case 31: + case 33: /* Line 1792 of yacc.c */ -#line 417 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 427 "glslang.y" { if ((yyvsp[(1) - (2)].interm).op != EOpNull) { char errorOp[2] = {0, 0}; @@ -3676,40 +3776,40 @@ yyreduce: } break; - case 32: -/* Line 1792 of yacc.c */ -#line 437 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpNull; } - break; - - case 33: -/* Line 1792 of yacc.c */ -#line 438 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpNegative; } - break; - case 34: /* Line 1792 of yacc.c */ -#line 439 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpLogicalNot; } +#line 447 "glslang.y" + { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpNull; } break; case 35: /* Line 1792 of yacc.c */ -#line 440 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpBitwiseNot; - parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "bitwise not"); } +#line 448 "glslang.y" + { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpNegative; } break; case 36: /* Line 1792 of yacc.c */ -#line 446 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } +#line 449 "glslang.y" + { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpLogicalNot; } break; case 37: /* Line 1792 of yacc.c */ -#line 447 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 450 "glslang.y" + { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpBitwiseNot; + parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "bitwise not"); } + break; + + case 38: +/* Line 1792 of yacc.c */ +#line 456 "glslang.y" + { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } + break; + + case 39: +/* Line 1792 of yacc.c */ +#line 457 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "*", EOpMul, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) @@ -3717,9 +3817,9 @@ yyreduce: } break; - case 38: + case 40: /* Line 1792 of yacc.c */ -#line 452 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 462 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "/", EOpDiv, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) @@ -3727,9 +3827,9 @@ yyreduce: } break; - case 39: + case 41: /* Line 1792 of yacc.c */ -#line 457 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 467 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(2) - (3)].lex).loc, "%"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "%", EOpMod, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); @@ -3738,15 +3838,15 @@ yyreduce: } break; - case 40: + case 42: /* Line 1792 of yacc.c */ -#line 466 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 476 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 41: + case 43: /* Line 1792 of yacc.c */ -#line 467 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 477 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "+", EOpAdd, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) @@ -3754,9 +3854,9 @@ yyreduce: } break; - case 42: + case 44: /* Line 1792 of yacc.c */ -#line 472 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 482 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "-", EOpSub, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) @@ -3764,15 +3864,15 @@ yyreduce: } break; - case 43: + case 45: /* Line 1792 of yacc.c */ -#line 480 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 490 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 44: + case 46: /* Line 1792 of yacc.c */ -#line 481 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 491 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(2) - (3)].lex).loc, "bit shift left"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "<<", EOpLeftShift, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); @@ -3781,9 +3881,9 @@ yyreduce: } break; - case 45: + case 47: /* Line 1792 of yacc.c */ -#line 487 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 497 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(2) - (3)].lex).loc, "bit shift right"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, ">>", EOpRightShift, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); @@ -3792,15 +3892,15 @@ yyreduce: } break; - case 46: + case 48: /* Line 1792 of yacc.c */ -#line 496 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 506 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 47: + case 49: /* Line 1792 of yacc.c */ -#line 497 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 507 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "<", EOpLessThan, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) @@ -3808,9 +3908,9 @@ yyreduce: } break; - case 48: + case 50: /* Line 1792 of yacc.c */ -#line 502 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 512 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, ">", EOpGreaterThan, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) @@ -3818,9 +3918,9 @@ yyreduce: } break; - case 49: + case 51: /* Line 1792 of yacc.c */ -#line 507 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 517 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "<=", EOpLessThanEqual, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) @@ -3828,9 +3928,9 @@ yyreduce: } break; - case 50: + case 52: /* Line 1792 of yacc.c */ -#line 512 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 522 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) @@ -3838,15 +3938,15 @@ yyreduce: } break; - case 51: + case 53: /* Line 1792 of yacc.c */ -#line 520 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 530 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 52: + case 54: /* Line 1792 of yacc.c */ -#line 521 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 531 "glslang.y" { parseContext.arrayObjectCheck((yyvsp[(2) - (3)].lex).loc, (yyvsp[(1) - (3)].interm.intermTypedNode)->getType(), "array comparison"); parseContext.opaqueCheck((yyvsp[(2) - (3)].lex).loc, (yyvsp[(1) - (3)].interm.intermTypedNode)->getType(), "=="); @@ -3857,9 +3957,9 @@ yyreduce: } break; - case 53: + case 55: /* Line 1792 of yacc.c */ -#line 529 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 539 "glslang.y" { parseContext.arrayObjectCheck((yyvsp[(2) - (3)].lex).loc, (yyvsp[(1) - (3)].interm.intermTypedNode)->getType(), "array comparison"); parseContext.opaqueCheck((yyvsp[(2) - (3)].lex).loc, (yyvsp[(1) - (3)].interm.intermTypedNode)->getType(), "!="); @@ -3870,15 +3970,15 @@ yyreduce: } break; - case 54: + case 56: /* Line 1792 of yacc.c */ -#line 540 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 550 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 55: + case 57: /* Line 1792 of yacc.c */ -#line 541 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 551 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(2) - (3)].lex).loc, "bitwise and"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "&", EOpAnd, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); @@ -3887,15 +3987,15 @@ yyreduce: } break; - case 56: + case 58: /* Line 1792 of yacc.c */ -#line 550 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 560 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 57: + case 59: /* Line 1792 of yacc.c */ -#line 551 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 561 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(2) - (3)].lex).loc, "bitwise exclusive or"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "^", EOpExclusiveOr, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); @@ -3904,15 +4004,15 @@ yyreduce: } break; - case 58: + case 60: /* Line 1792 of yacc.c */ -#line 560 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 570 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 59: + case 61: /* Line 1792 of yacc.c */ -#line 561 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 571 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(2) - (3)].lex).loc, "bitwise inclusive or"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "|", EOpInclusiveOr, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); @@ -3921,15 +4021,15 @@ yyreduce: } break; - case 60: + case 62: /* Line 1792 of yacc.c */ -#line 570 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 580 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 61: + case 63: /* Line 1792 of yacc.c */ -#line 571 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 581 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "&&", EOpLogicalAnd, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) @@ -3937,15 +4037,15 @@ yyreduce: } break; - case 62: + case 64: /* Line 1792 of yacc.c */ -#line 579 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 589 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 63: + case 65: /* Line 1792 of yacc.c */ -#line 580 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 590 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "^^", EOpLogicalXor, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) @@ -3953,15 +4053,15 @@ yyreduce: } break; - case 64: + case 66: /* Line 1792 of yacc.c */ -#line 588 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 598 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 65: + case 67: /* Line 1792 of yacc.c */ -#line 589 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 599 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "||", EOpLogicalOr, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) @@ -3969,23 +4069,23 @@ yyreduce: } break; - case 66: + case 68: /* Line 1792 of yacc.c */ -#line 597 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 607 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 67: + case 69: /* Line 1792 of yacc.c */ -#line 598 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 608 "glslang.y" { ++parseContext.controlFlowNestingLevel; } break; - case 68: + case 70: /* Line 1792 of yacc.c */ -#line 601 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 611 "glslang.y" { --parseContext.controlFlowNestingLevel; parseContext.boolCheck((yyvsp[(2) - (6)].lex).loc, (yyvsp[(1) - (6)].interm.intermTypedNode)); @@ -4000,15 +4100,15 @@ yyreduce: } break; - case 69: + case 71: /* Line 1792 of yacc.c */ -#line 616 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 626 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 70: + case 72: /* Line 1792 of yacc.c */ -#line 617 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 627 "glslang.y" { parseContext.arrayObjectCheck((yyvsp[(2) - (3)].interm).loc, (yyvsp[(1) - (3)].interm.intermTypedNode)->getType(), "array assignment"); parseContext.opaqueCheck((yyvsp[(2) - (3)].interm).loc, (yyvsp[(1) - (3)].interm.intermTypedNode)->getType(), "="); @@ -4023,36 +4123,36 @@ yyreduce: } break; - case 71: + case 73: /* Line 1792 of yacc.c */ -#line 632 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 642 "glslang.y" { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpAssign; } break; - case 72: + case 74: /* Line 1792 of yacc.c */ -#line 636 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 646 "glslang.y" { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpMulAssign; } break; - case 73: + case 75: /* Line 1792 of yacc.c */ -#line 640 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 650 "glslang.y" { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpDivAssign; } break; - case 74: + case 76: /* Line 1792 of yacc.c */ -#line 644 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 654 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "%="); (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; @@ -4060,80 +4160,80 @@ yyreduce: } break; - case 75: + case 77: /* Line 1792 of yacc.c */ -#line 649 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 659 "glslang.y" { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpAddAssign; } break; - case 76: + case 78: /* Line 1792 of yacc.c */ -#line 653 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 663 "glslang.y" { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpSubAssign; } break; - case 77: + case 79: /* Line 1792 of yacc.c */ -#line 657 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 667 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "bit-shift left assign"); (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpLeftShiftAssign; } break; - case 78: + case 80: /* Line 1792 of yacc.c */ -#line 661 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 671 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "bit-shift right assign"); (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpRightShiftAssign; } break; - case 79: + case 81: /* Line 1792 of yacc.c */ -#line 665 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 675 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "bitwise-and assign"); (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpAndAssign; } break; - case 80: + case 82: /* Line 1792 of yacc.c */ -#line 669 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 679 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "bitwise-xor assign"); (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign; } break; - case 81: + case 83: /* Line 1792 of yacc.c */ -#line 673 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 683 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "bitwise-or assign"); (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign; } break; - case 82: + case 84: /* Line 1792 of yacc.c */ -#line 680 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 690 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 83: + case 85: /* Line 1792 of yacc.c */ -#line 683 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 693 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode), (yyvsp[(2) - (3)].lex).loc); if ((yyval.interm.intermTypedNode) == 0) { @@ -4143,18 +4243,18 @@ yyreduce: } break; - case 84: + case 86: /* Line 1792 of yacc.c */ -#line 693 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 703 "glslang.y" { parseContext.constantValueCheck((yyvsp[(1) - (1)].interm.intermTypedNode), ""); (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 85: + case 87: /* Line 1792 of yacc.c */ -#line 700 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 710 "glslang.y" { parseContext.handleFunctionDeclarator((yyvsp[(1) - (2)].interm).loc, *(yyvsp[(1) - (2)].interm).function, true /* prototype */); (yyval.interm.intermNode) = 0; @@ -4162,9 +4262,9 @@ yyreduce: } break; - case 86: + case 88: /* Line 1792 of yacc.c */ -#line 705 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 715 "glslang.y" { if ((yyvsp[(1) - (2)].interm).intermNode && (yyvsp[(1) - (2)].interm).intermNode->getAsAggregate()) (yyvsp[(1) - (2)].interm).intermNode->getAsAggregate()->setOperator(EOpSequence); @@ -4172,9 +4272,9 @@ yyreduce: } break; - case 87: + case 89: /* Line 1792 of yacc.c */ -#line 710 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 720 "glslang.y" { parseContext.profileRequires((yyvsp[(1) - (4)].lex).loc, ENoProfile, 130, 0, "precision statement"); @@ -4185,36 +4285,36 @@ yyreduce: } break; - case 88: + case 90: /* Line 1792 of yacc.c */ -#line 718 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 728 "glslang.y" { parseContext.declareBlock((yyvsp[(1) - (2)].interm).loc, *(yyvsp[(1) - (2)].interm).typeList); (yyval.interm.intermNode) = 0; } break; - case 89: + case 91: /* Line 1792 of yacc.c */ -#line 722 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 732 "glslang.y" { parseContext.declareBlock((yyvsp[(1) - (3)].interm).loc, *(yyvsp[(1) - (3)].interm).typeList, (yyvsp[(2) - (3)].lex).string); (yyval.interm.intermNode) = 0; } break; - case 90: + case 92: /* Line 1792 of yacc.c */ -#line 726 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 736 "glslang.y" { parseContext.declareBlock((yyvsp[(1) - (4)].interm).loc, *(yyvsp[(1) - (4)].interm).typeList, (yyvsp[(2) - (4)].lex).string, (yyvsp[(3) - (4)].interm).arraySizes); (yyval.interm.intermNode) = 0; } break; - case 91: + case 93: /* Line 1792 of yacc.c */ -#line 730 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 740 "glslang.y" { parseContext.globalQualifierFixCheck((yyvsp[(1) - (2)].interm.type).loc, (yyvsp[(1) - (2)].interm.type).qualifier); parseContext.updateStandaloneQualifierDefaults((yyvsp[(1) - (2)].interm.type).loc, (yyvsp[(1) - (2)].interm.type)); @@ -4222,9 +4322,9 @@ yyreduce: } break; - case 92: + case 94: /* Line 1792 of yacc.c */ -#line 735 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 745 "glslang.y" { parseContext.checkNoShaderLayouts((yyvsp[(1) - (3)].interm.type).loc, (yyvsp[(1) - (3)].interm.type).shaderQualifiers); parseContext.addQualifierToExisting((yyvsp[(1) - (3)].interm.type).loc, (yyvsp[(1) - (3)].interm.type).qualifier, *(yyvsp[(2) - (3)].lex).string); @@ -4232,9 +4332,9 @@ yyreduce: } break; - case 93: + case 95: /* Line 1792 of yacc.c */ -#line 740 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 750 "glslang.y" { parseContext.checkNoShaderLayouts((yyvsp[(1) - (4)].interm.type).loc, (yyvsp[(1) - (4)].interm.type).shaderQualifiers); (yyvsp[(3) - (4)].interm.identifierList)->push_back((yyvsp[(2) - (4)].lex).string); @@ -4243,15 +4343,15 @@ yyreduce: } break; - case 94: + case 96: /* Line 1792 of yacc.c */ -#line 749 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 759 "glslang.y" { parseContext.nestedBlockCheck((yyvsp[(1) - (3)].interm.type).loc); } break; - case 95: + case 97: /* Line 1792 of yacc.c */ -#line 749 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 759 "glslang.y" { --parseContext.structNestingLevel; parseContext.blockName = (yyvsp[(2) - (6)].lex).string; @@ -4263,52 +4363,52 @@ yyreduce: } break; - case 96: + case 98: /* Line 1792 of yacc.c */ -#line 760 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 770 "glslang.y" { (yyval.interm.identifierList) = new TIdentifierList; (yyval.interm.identifierList)->push_back((yyvsp[(2) - (2)].lex).string); } break; - case 97: + case 99: /* Line 1792 of yacc.c */ -#line 764 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 774 "glslang.y" { (yyval.interm.identifierList) = (yyvsp[(1) - (3)].interm.identifierList); (yyval.interm.identifierList)->push_back((yyvsp[(3) - (3)].lex).string); } break; - case 98: + case 100: /* Line 1792 of yacc.c */ -#line 771 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 781 "glslang.y" { (yyval.interm).function = (yyvsp[(1) - (2)].interm.function); (yyval.interm).loc = (yyvsp[(2) - (2)].lex).loc; } break; - case 99: -/* Line 1792 of yacc.c */ -#line 778 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.function) = (yyvsp[(1) - (1)].interm.function); - } - break; - - case 100: -/* Line 1792 of yacc.c */ -#line 781 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.function) = (yyvsp[(1) - (1)].interm.function); - } - break; - case 101: /* Line 1792 of yacc.c */ -#line 788 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 788 "glslang.y" + { + (yyval.interm.function) = (yyvsp[(1) - (1)].interm.function); + } + break; + + case 102: +/* Line 1792 of yacc.c */ +#line 791 "glslang.y" + { + (yyval.interm.function) = (yyvsp[(1) - (1)].interm.function); + } + break; + + case 103: +/* Line 1792 of yacc.c */ +#line 798 "glslang.y" { // Add the parameter (yyval.interm.function) = (yyvsp[(1) - (2)].interm.function); @@ -4319,9 +4419,9 @@ yyreduce: } break; - case 102: + case 104: /* Line 1792 of yacc.c */ -#line 796 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 806 "glslang.y" { // // Only first parameter of one-parameter functions can be void @@ -4341,9 +4441,9 @@ yyreduce: } break; - case 103: + case 105: /* Line 1792 of yacc.c */ -#line 816 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 826 "glslang.y" { if ((yyvsp[(1) - (3)].interm.type).qualifier.storage != EvqGlobal && (yyvsp[(1) - (3)].interm.type).qualifier.storage != EvqTemporary) { parseContext.error((yyvsp[(2) - (3)].lex).loc, "no qualifiers allowed for function return", @@ -4360,9 +4460,9 @@ yyreduce: } break; - case 104: + case 106: /* Line 1792 of yacc.c */ -#line 834 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 844 "glslang.y" { if ((yyvsp[(1) - (2)].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[(1) - (2)].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -4380,9 +4480,9 @@ yyreduce: } break; - case 105: + case 107: /* Line 1792 of yacc.c */ -#line 849 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 859 "glslang.y" { if ((yyvsp[(1) - (3)].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[(1) - (3)].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -4402,9 +4502,9 @@ yyreduce: } break; - case 106: + case 108: /* Line 1792 of yacc.c */ -#line 872 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 882 "glslang.y" { (yyval.interm) = (yyvsp[(2) - (2)].interm); if ((yyvsp[(1) - (2)].interm.type).qualifier.precision != EpqNone) @@ -4418,9 +4518,9 @@ yyreduce: } break; - case 107: + case 109: /* Line 1792 of yacc.c */ -#line 883 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 893 "glslang.y" { (yyval.interm) = (yyvsp[(1) - (1)].interm); @@ -4430,9 +4530,9 @@ yyreduce: } break; - case 108: + case 110: /* Line 1792 of yacc.c */ -#line 893 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 903 "glslang.y" { (yyval.interm) = (yyvsp[(2) - (2)].interm); if ((yyvsp[(1) - (2)].interm.type).qualifier.precision != EpqNone) @@ -4445,9 +4545,9 @@ yyreduce: } break; - case 109: + case 111: /* Line 1792 of yacc.c */ -#line 903 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 913 "glslang.y" { (yyval.interm) = (yyvsp[(1) - (1)].interm); @@ -4457,9 +4557,9 @@ yyreduce: } break; - case 110: + case 112: /* Line 1792 of yacc.c */ -#line 913 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 923 "glslang.y" { TParameter param = { 0, new TType((yyvsp[(1) - (1)].interm.type)) }; (yyval.interm).param = param; @@ -4468,35 +4568,35 @@ yyreduce: } break; - case 111: + case 113: /* Line 1792 of yacc.c */ -#line 922 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 932 "glslang.y" { (yyval.interm) = (yyvsp[(1) - (1)].interm); } break; - case 112: + case 114: /* Line 1792 of yacc.c */ -#line 925 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 935 "glslang.y" { (yyval.interm) = (yyvsp[(1) - (3)].interm); parseContext.declareVariable((yyvsp[(3) - (3)].lex).loc, *(yyvsp[(3) - (3)].lex).string, (yyvsp[(1) - (3)].interm).type); } break; - case 113: + case 115: /* Line 1792 of yacc.c */ -#line 929 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 939 "glslang.y" { (yyval.interm) = (yyvsp[(1) - (4)].interm); parseContext.declareVariable((yyvsp[(3) - (4)].lex).loc, *(yyvsp[(3) - (4)].lex).string, (yyvsp[(1) - (4)].interm).type, (yyvsp[(4) - (4)].interm).arraySizes); } break; - case 114: + case 116: /* Line 1792 of yacc.c */ -#line 933 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 943 "glslang.y" { (yyval.interm).type = (yyvsp[(1) - (6)].interm).type; TIntermNode* initNode = parseContext.declareVariable((yyvsp[(3) - (6)].lex).loc, *(yyvsp[(3) - (6)].lex).string, (yyvsp[(1) - (6)].interm).type, (yyvsp[(4) - (6)].interm).arraySizes, (yyvsp[(6) - (6)].interm.intermTypedNode)); @@ -4504,9 +4604,9 @@ yyreduce: } break; - case 115: + case 117: /* Line 1792 of yacc.c */ -#line 938 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 948 "glslang.y" { (yyval.interm).type = (yyvsp[(1) - (5)].interm).type; TIntermNode* initNode = parseContext.declareVariable((yyvsp[(3) - (5)].lex).loc, *(yyvsp[(3) - (5)].lex).string, (yyvsp[(1) - (5)].interm).type, 0, (yyvsp[(5) - (5)].interm.intermTypedNode)); @@ -4514,9 +4614,9 @@ yyreduce: } break; - case 116: + case 118: /* Line 1792 of yacc.c */ -#line 946 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 956 "glslang.y" { (yyval.interm).type = (yyvsp[(1) - (1)].interm.type); (yyval.interm).intermNode = 0; @@ -4524,9 +4624,9 @@ yyreduce: } break; - case 117: + case 119: /* Line 1792 of yacc.c */ -#line 951 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 961 "glslang.y" { (yyval.interm).type = (yyvsp[(1) - (2)].interm.type); (yyval.interm).intermNode = 0; @@ -4534,9 +4634,9 @@ yyreduce: } break; - case 118: + case 120: /* Line 1792 of yacc.c */ -#line 956 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 966 "glslang.y" { (yyval.interm).type = (yyvsp[(1) - (3)].interm.type); (yyval.interm).intermNode = 0; @@ -4544,9 +4644,9 @@ yyreduce: } break; - case 119: + case 121: /* Line 1792 of yacc.c */ -#line 961 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 971 "glslang.y" { (yyval.interm).type = (yyvsp[(1) - (5)].interm.type); TIntermNode* initNode = parseContext.declareVariable((yyvsp[(2) - (5)].lex).loc, *(yyvsp[(2) - (5)].lex).string, (yyvsp[(1) - (5)].interm.type), (yyvsp[(3) - (5)].interm).arraySizes, (yyvsp[(5) - (5)].interm.intermTypedNode)); @@ -4554,9 +4654,9 @@ yyreduce: } break; - case 120: + case 122: /* Line 1792 of yacc.c */ -#line 966 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 976 "glslang.y" { (yyval.interm).type = (yyvsp[(1) - (4)].interm.type); TIntermNode* initNode = parseContext.declareVariable((yyvsp[(2) - (4)].lex).loc, *(yyvsp[(2) - (4)].lex).string, (yyvsp[(1) - (4)].interm.type), 0, (yyvsp[(4) - (4)].interm.intermTypedNode)); @@ -4564,9 +4664,9 @@ yyreduce: } break; - case 121: + case 123: /* Line 1792 of yacc.c */ -#line 975 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 985 "glslang.y" { (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type); @@ -4580,9 +4680,9 @@ yyreduce: } break; - case 122: + case 124: /* Line 1792 of yacc.c */ -#line 986 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 996 "glslang.y" { parseContext.globalQualifierFixCheck((yyvsp[(1) - (2)].interm.type).loc, (yyvsp[(1) - (2)].interm.type).qualifier); parseContext.globalQualifierTypeCheck((yyvsp[(1) - (2)].interm.type).loc, (yyvsp[(1) - (2)].interm.type).qualifier, (yyvsp[(2) - (2)].interm.type)); @@ -4609,9 +4709,9 @@ yyreduce: } break; - case 123: + case 125: /* Line 1792 of yacc.c */ -#line 1013 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1023 "glslang.y" { parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "invariant"); parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant"); @@ -4620,9 +4720,9 @@ yyreduce: } break; - case 124: + case 126: /* Line 1792 of yacc.c */ -#line 1022 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1032 "glslang.y" { parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "smooth"); parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ENoProfile, 130, 0, "smooth"); @@ -4632,9 +4732,9 @@ yyreduce: } break; - case 125: + case 127: /* Line 1792 of yacc.c */ -#line 1029 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1039 "glslang.y" { parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "flat"); parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ENoProfile, 130, 0, "flat"); @@ -4644,9 +4744,9 @@ yyreduce: } break; - case 126: + case 128: /* Line 1792 of yacc.c */ -#line 1036 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1046 "glslang.y" { parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "noperspective"); parseContext.requireProfile((yyvsp[(1) - (1)].lex).loc, ~EEsProfile, "noperspective"); @@ -4656,25 +4756,25 @@ yyreduce: } break; - case 127: + case 129: /* Line 1792 of yacc.c */ -#line 1046 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1056 "glslang.y" { (yyval.interm.type) = (yyvsp[(3) - (4)].interm.type); } break; - case 128: + case 130: /* Line 1792 of yacc.c */ -#line 1052 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1062 "glslang.y" { (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type); } break; - case 129: + case 131: /* Line 1792 of yacc.c */ -#line 1055 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1065 "glslang.y" { (yyval.interm.type) = (yyvsp[(1) - (3)].interm.type); (yyval.interm.type).shaderQualifiers.merge((yyvsp[(3) - (3)].interm.type).shaderQualifiers); @@ -4682,27 +4782,27 @@ yyreduce: } break; - case 130: + case 132: /* Line 1792 of yacc.c */ -#line 1062 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1072 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); parseContext.setLayoutQualifier((yyvsp[(1) - (1)].lex).loc, (yyval.interm.type), *(yyvsp[(1) - (1)].lex).string); } break; - case 131: + case 133: /* Line 1792 of yacc.c */ -#line 1066 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1076 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (3)].lex).loc); parseContext.setLayoutQualifier((yyvsp[(1) - (3)].lex).loc, (yyval.interm.type), *(yyvsp[(1) - (3)].lex).string, (yyvsp[(3) - (3)].interm.intermTypedNode)); } break; - case 132: + case 134: /* Line 1792 of yacc.c */ -#line 1070 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1080 "glslang.y" { // because "shared" is both an identifier and a keyword (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); TString strShared("shared"); @@ -4710,25 +4810,25 @@ yyreduce: } break; - case 133: + case 135: /* Line 1792 of yacc.c */ -#line 1078 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1088 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); } break; - case 134: + case 136: /* Line 1792 of yacc.c */ -#line 1084 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1094 "glslang.y" { (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type); } break; - case 135: + case 137: /* Line 1792 of yacc.c */ -#line 1087 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1097 "glslang.y" { (yyval.interm.type) = (yyvsp[(1) - (2)].interm.type); if ((yyval.interm.type).basicType == EbtVoid) @@ -4739,25 +4839,9 @@ yyreduce: } break; - case 136: -/* Line 1792 of yacc.c */ -#line 1098 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type); - } - break; - - case 137: -/* Line 1792 of yacc.c */ -#line 1101 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type); - } - break; - case 138: /* Line 1792 of yacc.c */ -#line 1104 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1108 "glslang.y" { (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type); } @@ -4765,25 +4849,23 @@ yyreduce: case 139: /* Line 1792 of yacc.c */ -#line 1107 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1111 "glslang.y" { - // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type); } break; case 140: /* Line 1792 of yacc.c */ -#line 1111 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1114 "glslang.y" { - // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type); } break; case 141: /* Line 1792 of yacc.c */ -#line 1115 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1117 "glslang.y" { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type); @@ -4792,16 +4874,34 @@ yyreduce: case 142: /* Line 1792 of yacc.c */ -#line 1122 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1121 "glslang.y" + { + // allow inheritance of storage qualifier from block declaration + (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type); + } + break; + + case 143: +/* Line 1792 of yacc.c */ +#line 1125 "glslang.y" + { + // allow inheritance of storage qualifier from block declaration + (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type); + } + break; + + case 144: +/* Line 1792 of yacc.c */ +#line 1132 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); (yyval.interm.type).qualifier.storage = EvqConst; // will later turn into EvqConstReadOnly, if the initializer is not constant } break; - case 143: + case 145: /* Line 1792 of yacc.c */ -#line 1126 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1136 "glslang.y" { parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangVertex, "attribute"); parseContext.checkDeprecated((yyvsp[(1) - (1)].lex).loc, ECoreProfile, 130, "attribute"); @@ -4816,9 +4916,9 @@ yyreduce: } break; - case 144: + case 146: /* Line 1792 of yacc.c */ -#line 1138 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1148 "glslang.y" { parseContext.checkDeprecated((yyvsp[(1) - (1)].lex).loc, ENoProfile, 130, "varying"); parseContext.checkDeprecated((yyvsp[(1) - (1)].lex).loc, ECoreProfile, 130, "varying"); @@ -4835,9 +4935,9 @@ yyreduce: } break; - case 145: + case 147: /* Line 1792 of yacc.c */ -#line 1152 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1162 "glslang.y" { parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "inout"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); @@ -4845,9 +4945,9 @@ yyreduce: } break; - case 146: + case 148: /* Line 1792 of yacc.c */ -#line 1157 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1167 "glslang.y" { parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "in"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); @@ -4856,9 +4956,9 @@ yyreduce: } break; - case 147: + case 149: /* Line 1792 of yacc.c */ -#line 1163 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1173 "glslang.y" { parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "out"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); @@ -4867,9 +4967,9 @@ yyreduce: } break; - case 148: + case 150: /* Line 1792 of yacc.c */ -#line 1169 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1179 "glslang.y" { parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ENoProfile, 120, 0, "centroid"); parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, EEsProfile, 300, 0, "centroid"); @@ -4879,9 +4979,9 @@ yyreduce: } break; - case 149: + case 151: /* Line 1792 of yacc.c */ -#line 1176 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1186 "glslang.y" { parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "patch"); parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch"); @@ -4890,9 +4990,9 @@ yyreduce: } break; - case 150: + case 152: /* Line 1792 of yacc.c */ -#line 1182 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1192 "glslang.y" { parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "sample"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); @@ -4900,9 +5000,9 @@ yyreduce: } break; - case 151: + case 153: /* Line 1792 of yacc.c */ -#line 1187 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1197 "glslang.y" { parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "uniform"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); @@ -4910,9 +5010,9 @@ yyreduce: } break; - case 152: + case 154: /* Line 1792 of yacc.c */ -#line 1192 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1202 "glslang.y" { parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "buffer"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); @@ -4920,9 +5020,9 @@ yyreduce: } break; - case 153: + case 155: /* Line 1792 of yacc.c */ -#line 1197 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1207 "glslang.y" { parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ECoreProfile | ECompatibilityProfile, 430, 0, "shared"); parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, EEsProfile, 310, 0, "shared"); @@ -4932,54 +5032,54 @@ yyreduce: } break; - case 154: + case 156: /* Line 1792 of yacc.c */ -#line 1204 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1214 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); (yyval.interm.type).qualifier.coherent = true; } break; - case 155: + case 157: /* Line 1792 of yacc.c */ -#line 1208 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1218 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); (yyval.interm.type).qualifier.volatil = true; } break; - case 156: + case 158: /* Line 1792 of yacc.c */ -#line 1212 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1222 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); (yyval.interm.type).qualifier.restrict = true; } break; - case 157: + case 159: /* Line 1792 of yacc.c */ -#line 1216 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1226 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); (yyval.interm.type).qualifier.readonly = true; } break; - case 158: + case 160: /* Line 1792 of yacc.c */ -#line 1220 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1230 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc); (yyval.interm.type).qualifier.writeonly = true; } break; - case 159: + case 161: /* Line 1792 of yacc.c */ -#line 1224 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1234 "glslang.y" { parseContext.spvRemoved((yyvsp[(1) - (1)].lex).loc, "subroutine"); parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "subroutine"); @@ -4988,9 +5088,9 @@ yyreduce: } break; - case 160: + case 162: /* Line 1792 of yacc.c */ -#line 1230 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1240 "glslang.y" { parseContext.spvRemoved((yyvsp[(1) - (4)].lex).loc, "subroutine"); parseContext.globalCheck((yyvsp[(1) - (4)].lex).loc, "subroutine"); @@ -5002,33 +5102,33 @@ yyreduce: } break; - case 161: + case 163: /* Line 1792 of yacc.c */ -#line 1242 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1252 "glslang.y" { // TODO: 4.0 functionality: subroutine type to list } break; - case 162: + case 164: /* Line 1792 of yacc.c */ -#line 1245 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1255 "glslang.y" { } break; - case 163: + case 165: /* Line 1792 of yacc.c */ -#line 1250 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1260 "glslang.y" { (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type); (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); } break; - case 164: + case 166: /* Line 1792 of yacc.c */ -#line 1254 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1264 "glslang.y" { parseContext.arrayDimCheck((yyvsp[(2) - (2)].interm).loc, (yyvsp[(2) - (2)].interm).arraySizes, 0); (yyval.interm.type) = (yyvsp[(1) - (2)].interm.type); @@ -5037,9 +5137,9 @@ yyreduce: } break; - case 165: + case 167: /* Line 1792 of yacc.c */ -#line 1263 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1273 "glslang.y" { (yyval.interm).loc = (yyvsp[(1) - (2)].lex).loc; (yyval.interm).arraySizes = new TArraySizes; @@ -5047,9 +5147,9 @@ yyreduce: } break; - case 166: + case 168: /* Line 1792 of yacc.c */ -#line 1268 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1278 "glslang.y" { (yyval.interm).loc = (yyvsp[(1) - (3)].lex).loc; (yyval.interm).arraySizes = new TArraySizes; @@ -5060,18 +5160,18 @@ yyreduce: } break; - case 167: + case 169: /* Line 1792 of yacc.c */ -#line 1276 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1286 "glslang.y" { (yyval.interm) = (yyvsp[(1) - (3)].interm); (yyval.interm).arraySizes->addInnerSize(); } break; - case 168: + case 170: /* Line 1792 of yacc.c */ -#line 1280 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1290 "glslang.y" { (yyval.interm) = (yyvsp[(1) - (4)].interm); @@ -5081,27 +5181,27 @@ yyreduce: } break; - case 169: + case 171: /* Line 1792 of yacc.c */ -#line 1290 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1300 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtVoid; } break; - case 170: + case 172: /* Line 1792 of yacc.c */ -#line 1294 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1304 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } break; - case 171: + case 173: /* Line 1792 of yacc.c */ -#line 1298 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1308 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5109,18 +5209,18 @@ yyreduce: } break; - case 172: + case 174: /* Line 1792 of yacc.c */ -#line 1303 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1313 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } break; - case 173: + case 175: /* Line 1792 of yacc.c */ -#line 1307 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1317 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "unsigned integer"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5128,70 +5228,90 @@ yyreduce: } break; - case 174: -/* Line 1792 of yacc.c */ -#line 1312 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtBool; - } - break; - - case 175: -/* Line 1792 of yacc.c */ -#line 1316 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setVector(2); - } - break; - case 176: /* Line 1792 of yacc.c */ -#line 1321 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1322 "glslang.y" { + parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setVector(3); + (yyval.interm.type).basicType = EbtInt64; } break; case 177: /* Line 1792 of yacc.c */ -#line 1326 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1327 "glslang.y" { + parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setVector(4); + (yyval.interm.type).basicType = EbtUint64; } break; case 178: /* Line 1792 of yacc.c */ -#line 1331 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1332 "glslang.y" { - parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double vector"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(2); + (yyval.interm.type).basicType = EbtBool; } break; case 179: /* Line 1792 of yacc.c */ -#line 1337 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1336 "glslang.y" { - parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double vector"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(3); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setVector(2); } break; case 180: /* Line 1792 of yacc.c */ -#line 1343 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1341 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setVector(3); + } + break; + + case 181: +/* Line 1792 of yacc.c */ +#line 1346 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setVector(4); + } + break; + + case 182: +/* Line 1792 of yacc.c */ +#line 1351 "glslang.y" + { + parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double vector"); + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setVector(2); + } + break; + + case 183: +/* Line 1792 of yacc.c */ +#line 1357 "glslang.y" + { + parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double vector"); + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setVector(3); + } + break; + + case 184: +/* Line 1792 of yacc.c */ +#line 1363 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double vector"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5200,59 +5320,59 @@ yyreduce: } break; - case 181: -/* Line 1792 of yacc.c */ -#line 1349 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtBool; - (yyval.interm.type).setVector(2); - } - break; - - case 182: -/* Line 1792 of yacc.c */ -#line 1354 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtBool; - (yyval.interm.type).setVector(3); - } - break; - - case 183: -/* Line 1792 of yacc.c */ -#line 1359 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtBool; - (yyval.interm.type).setVector(4); - } - break; - - case 184: -/* Line 1792 of yacc.c */ -#line 1364 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt; - (yyval.interm.type).setVector(2); - } - break; - case 185: /* Line 1792 of yacc.c */ -#line 1369 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1369 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt; - (yyval.interm.type).setVector(3); + (yyval.interm.type).basicType = EbtBool; + (yyval.interm.type).setVector(2); } break; case 186: /* Line 1792 of yacc.c */ -#line 1374 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1374 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtBool; + (yyval.interm.type).setVector(3); + } + break; + + case 187: +/* Line 1792 of yacc.c */ +#line 1379 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtBool; + (yyval.interm.type).setVector(4); + } + break; + + case 188: +/* Line 1792 of yacc.c */ +#line 1384 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).setVector(2); + } + break; + + case 189: +/* Line 1792 of yacc.c */ +#line 1389 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).setVector(3); + } + break; + + case 190: +/* Line 1792 of yacc.c */ +#line 1394 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; @@ -5260,9 +5380,42 @@ yyreduce: } break; - case 187: + case 191: /* Line 1792 of yacc.c */ -#line 1379 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1399 "glslang.y" + { + parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt64; + (yyval.interm.type).setVector(2); + } + break; + + case 192: +/* Line 1792 of yacc.c */ +#line 1405 "glslang.y" + { + parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt64; + (yyval.interm.type).setVector(3); + } + break; + + case 193: +/* Line 1792 of yacc.c */ +#line 1411 "glslang.y" + { + parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt64; + (yyval.interm.type).setVector(4); + } + break; + + case 194: +/* Line 1792 of yacc.c */ +#line 1417 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "unsigned integer vector"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5271,9 +5424,9 @@ yyreduce: } break; - case 188: + case 195: /* Line 1792 of yacc.c */ -#line 1385 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1423 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "unsigned integer vector"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5282,9 +5435,9 @@ yyreduce: } break; - case 189: + case 196: /* Line 1792 of yacc.c */ -#line 1391 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1429 "glslang.y" { parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "unsigned integer vector"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5293,119 +5446,62 @@ yyreduce: } break; - case 190: -/* Line 1792 of yacc.c */ -#line 1397 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 2); - } - break; - - case 191: -/* Line 1792 of yacc.c */ -#line 1402 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(3, 3); - } - break; - - case 192: -/* Line 1792 of yacc.c */ -#line 1407 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(4, 4); - } - break; - - case 193: -/* Line 1792 of yacc.c */ -#line 1412 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 2); - } - break; - - case 194: -/* Line 1792 of yacc.c */ -#line 1417 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 3); - } - break; - - case 195: -/* Line 1792 of yacc.c */ -#line 1422 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 4); - } - break; - - case 196: -/* Line 1792 of yacc.c */ -#line 1427 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { - (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(3, 2); - } - break; - case 197: /* Line 1792 of yacc.c */ -#line 1432 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1435 "glslang.y" { + parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(3, 3); + (yyval.interm.type).basicType = EbtUint64; + (yyval.interm.type).setVector(2); } break; case 198: /* Line 1792 of yacc.c */ -#line 1437 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1441 "glslang.y" { + parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(3, 4); + (yyval.interm.type).basicType = EbtUint64; + (yyval.interm.type).setVector(3); } break; case 199: /* Line 1792 of yacc.c */ -#line 1442 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1447 "glslang.y" { + parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(4, 2); + (yyval.interm.type).basicType = EbtUint64; + (yyval.interm.type).setVector(4); } break; case 200: /* Line 1792 of yacc.c */ -#line 1447 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1453 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(4, 3); + (yyval.interm.type).setMatrix(2, 2); } break; case 201: /* Line 1792 of yacc.c */ -#line 1452 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1458 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(3, 3); + } + break; + + case 202: +/* Line 1792 of yacc.c */ +#line 1463 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; @@ -5413,9 +5509,99 @@ yyreduce: } break; - case 202: + case 203: /* Line 1792 of yacc.c */ -#line 1457 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1468 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(2, 2); + } + break; + + case 204: +/* Line 1792 of yacc.c */ +#line 1473 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(2, 3); + } + break; + + case 205: +/* Line 1792 of yacc.c */ +#line 1478 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(2, 4); + } + break; + + case 206: +/* Line 1792 of yacc.c */ +#line 1483 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(3, 2); + } + break; + + case 207: +/* Line 1792 of yacc.c */ +#line 1488 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(3, 3); + } + break; + + case 208: +/* Line 1792 of yacc.c */ +#line 1493 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(3, 4); + } + break; + + case 209: +/* Line 1792 of yacc.c */ +#line 1498 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(4, 2); + } + break; + + case 210: +/* Line 1792 of yacc.c */ +#line 1503 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(4, 3); + } + break; + + case 211: +/* Line 1792 of yacc.c */ +#line 1508 "glslang.y" + { + (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(4, 4); + } + break; + + case 212: +/* Line 1792 of yacc.c */ +#line 1513 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5424,9 +5610,9 @@ yyreduce: } break; - case 203: + case 213: /* Line 1792 of yacc.c */ -#line 1463 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1519 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5435,9 +5621,9 @@ yyreduce: } break; - case 204: + case 214: /* Line 1792 of yacc.c */ -#line 1469 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1525 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5446,9 +5632,9 @@ yyreduce: } break; - case 205: + case 215: /* Line 1792 of yacc.c */ -#line 1475 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1531 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5457,9 +5643,9 @@ yyreduce: } break; - case 206: + case 216: /* Line 1792 of yacc.c */ -#line 1481 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1537 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5468,9 +5654,9 @@ yyreduce: } break; - case 207: + case 217: /* Line 1792 of yacc.c */ -#line 1487 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1543 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5479,9 +5665,9 @@ yyreduce: } break; - case 208: + case 218: /* Line 1792 of yacc.c */ -#line 1493 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1549 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5490,9 +5676,9 @@ yyreduce: } break; - case 209: + case 219: /* Line 1792 of yacc.c */ -#line 1499 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1555 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5501,9 +5687,9 @@ yyreduce: } break; - case 210: + case 220: /* Line 1792 of yacc.c */ -#line 1505 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1561 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5512,9 +5698,9 @@ yyreduce: } break; - case 211: + case 221: /* Line 1792 of yacc.c */ -#line 1511 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1567 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5523,9 +5709,9 @@ yyreduce: } break; - case 212: + case 222: /* Line 1792 of yacc.c */ -#line 1517 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1573 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5534,9 +5720,9 @@ yyreduce: } break; - case 213: + case 223: /* Line 1792 of yacc.c */ -#line 1523 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1579 "glslang.y" { parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5545,9 +5731,9 @@ yyreduce: } break; - case 214: + case 224: /* Line 1792 of yacc.c */ -#line 1529 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1585 "glslang.y" { parseContext.vulkanRemoved((yyvsp[(1) - (1)].lex).loc, "atomic counter types"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -5555,9 +5741,9 @@ yyreduce: } break; - case 215: + case 225: /* Line 1792 of yacc.c */ -#line 1534 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1590 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5565,9 +5751,9 @@ yyreduce: } break; - case 216: + case 226: /* Line 1792 of yacc.c */ -#line 1539 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1595 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5575,9 +5761,9 @@ yyreduce: } break; - case 217: + case 227: /* Line 1792 of yacc.c */ -#line 1544 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1600 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5585,9 +5771,9 @@ yyreduce: } break; - case 218: + case 228: /* Line 1792 of yacc.c */ -#line 1549 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1605 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5595,9 +5781,9 @@ yyreduce: } break; - case 219: + case 229: /* Line 1792 of yacc.c */ -#line 1554 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1610 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5605,9 +5791,9 @@ yyreduce: } break; - case 220: + case 230: /* Line 1792 of yacc.c */ -#line 1559 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1615 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5615,9 +5801,9 @@ yyreduce: } break; - case 221: + case 231: /* Line 1792 of yacc.c */ -#line 1564 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1620 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5625,9 +5811,9 @@ yyreduce: } break; - case 222: + case 232: /* Line 1792 of yacc.c */ -#line 1569 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1625 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5635,9 +5821,9 @@ yyreduce: } break; - case 223: + case 233: /* Line 1792 of yacc.c */ -#line 1574 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1630 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5645,9 +5831,9 @@ yyreduce: } break; - case 224: + case 234: /* Line 1792 of yacc.c */ -#line 1579 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1635 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5655,9 +5841,9 @@ yyreduce: } break; - case 225: + case 235: /* Line 1792 of yacc.c */ -#line 1584 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1640 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5665,9 +5851,9 @@ yyreduce: } break; - case 226: + case 236: /* Line 1792 of yacc.c */ -#line 1589 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1645 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5675,9 +5861,9 @@ yyreduce: } break; - case 227: + case 237: /* Line 1792 of yacc.c */ -#line 1594 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1650 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5685,9 +5871,9 @@ yyreduce: } break; - case 228: + case 238: /* Line 1792 of yacc.c */ -#line 1599 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1655 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5695,9 +5881,9 @@ yyreduce: } break; - case 229: + case 239: /* Line 1792 of yacc.c */ -#line 1604 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1660 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5705,9 +5891,9 @@ yyreduce: } break; - case 230: + case 240: /* Line 1792 of yacc.c */ -#line 1609 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1665 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5715,9 +5901,9 @@ yyreduce: } break; - case 231: + case 241: /* Line 1792 of yacc.c */ -#line 1614 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1670 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5725,9 +5911,9 @@ yyreduce: } break; - case 232: + case 242: /* Line 1792 of yacc.c */ -#line 1619 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1675 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5735,9 +5921,9 @@ yyreduce: } break; - case 233: + case 243: /* Line 1792 of yacc.c */ -#line 1624 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1680 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5745,9 +5931,9 @@ yyreduce: } break; - case 234: + case 244: /* Line 1792 of yacc.c */ -#line 1629 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1685 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5755,9 +5941,9 @@ yyreduce: } break; - case 235: + case 245: /* Line 1792 of yacc.c */ -#line 1634 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1690 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5765,9 +5951,9 @@ yyreduce: } break; - case 236: + case 246: /* Line 1792 of yacc.c */ -#line 1639 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1695 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5775,9 +5961,9 @@ yyreduce: } break; - case 237: + case 247: /* Line 1792 of yacc.c */ -#line 1644 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1700 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5785,9 +5971,9 @@ yyreduce: } break; - case 238: + case 248: /* Line 1792 of yacc.c */ -#line 1649 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1705 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5795,9 +5981,9 @@ yyreduce: } break; - case 239: + case 249: /* Line 1792 of yacc.c */ -#line 1654 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1710 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5805,9 +5991,9 @@ yyreduce: } break; - case 240: + case 250: /* Line 1792 of yacc.c */ -#line 1659 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1715 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5815,9 +6001,9 @@ yyreduce: } break; - case 241: + case 251: /* Line 1792 of yacc.c */ -#line 1664 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1720 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5825,9 +6011,9 @@ yyreduce: } break; - case 242: + case 252: /* Line 1792 of yacc.c */ -#line 1669 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1725 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5835,9 +6021,9 @@ yyreduce: } break; - case 243: + case 253: /* Line 1792 of yacc.c */ -#line 1674 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1730 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5845,9 +6031,9 @@ yyreduce: } break; - case 244: + case 254: /* Line 1792 of yacc.c */ -#line 1679 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1735 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5855,9 +6041,9 @@ yyreduce: } break; - case 245: + case 255: /* Line 1792 of yacc.c */ -#line 1684 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1740 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5865,9 +6051,9 @@ yyreduce: } break; - case 246: + case 256: /* Line 1792 of yacc.c */ -#line 1689 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1745 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5875,9 +6061,9 @@ yyreduce: } break; - case 247: + case 257: /* Line 1792 of yacc.c */ -#line 1694 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1750 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5885,9 +6071,9 @@ yyreduce: } break; - case 248: + case 258: /* Line 1792 of yacc.c */ -#line 1699 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1755 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5895,9 +6081,9 @@ yyreduce: } break; - case 249: + case 259: /* Line 1792 of yacc.c */ -#line 1704 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1760 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5905,9 +6091,9 @@ yyreduce: } break; - case 250: + case 260: /* Line 1792 of yacc.c */ -#line 1709 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1765 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5915,9 +6101,9 @@ yyreduce: } break; - case 251: + case 261: /* Line 1792 of yacc.c */ -#line 1714 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1770 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5925,9 +6111,9 @@ yyreduce: } break; - case 252: + case 262: /* Line 1792 of yacc.c */ -#line 1719 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1775 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5935,9 +6121,9 @@ yyreduce: } break; - case 253: + case 263: /* Line 1792 of yacc.c */ -#line 1724 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1780 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5945,9 +6131,9 @@ yyreduce: } break; - case 254: + case 264: /* Line 1792 of yacc.c */ -#line 1729 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1785 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5955,9 +6141,9 @@ yyreduce: } break; - case 255: + case 265: /* Line 1792 of yacc.c */ -#line 1734 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1790 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5965,9 +6151,9 @@ yyreduce: } break; - case 256: + case 266: /* Line 1792 of yacc.c */ -#line 1739 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1795 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5975,9 +6161,9 @@ yyreduce: } break; - case 257: + case 267: /* Line 1792 of yacc.c */ -#line 1744 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1800 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5985,9 +6171,9 @@ yyreduce: } break; - case 258: + case 268: /* Line 1792 of yacc.c */ -#line 1749 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1805 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -5995,9 +6181,9 @@ yyreduce: } break; - case 259: + case 269: /* Line 1792 of yacc.c */ -#line 1754 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1810 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6005,9 +6191,9 @@ yyreduce: } break; - case 260: + case 270: /* Line 1792 of yacc.c */ -#line 1759 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1815 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6015,9 +6201,9 @@ yyreduce: } break; - case 261: + case 271: /* Line 1792 of yacc.c */ -#line 1764 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1820 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6025,9 +6211,9 @@ yyreduce: } break; - case 262: + case 272: /* Line 1792 of yacc.c */ -#line 1769 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1825 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6035,9 +6221,9 @@ yyreduce: } break; - case 263: + case 273: /* Line 1792 of yacc.c */ -#line 1774 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1830 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6045,9 +6231,9 @@ yyreduce: } break; - case 264: + case 274: /* Line 1792 of yacc.c */ -#line 1779 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1835 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6055,9 +6241,9 @@ yyreduce: } break; - case 265: + case 275: /* Line 1792 of yacc.c */ -#line 1784 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1840 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6065,9 +6251,9 @@ yyreduce: } break; - case 266: + case 276: /* Line 1792 of yacc.c */ -#line 1789 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1845 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6075,9 +6261,9 @@ yyreduce: } break; - case 267: + case 277: /* Line 1792 of yacc.c */ -#line 1794 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1850 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6085,9 +6271,9 @@ yyreduce: } break; - case 268: + case 278: /* Line 1792 of yacc.c */ -#line 1799 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1855 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6095,9 +6281,9 @@ yyreduce: } break; - case 269: + case 279: /* Line 1792 of yacc.c */ -#line 1804 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1860 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6105,9 +6291,9 @@ yyreduce: } break; - case 270: + case 280: /* Line 1792 of yacc.c */ -#line 1809 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1865 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6115,9 +6301,9 @@ yyreduce: } break; - case 271: + case 281: /* Line 1792 of yacc.c */ -#line 1814 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1870 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6125,9 +6311,9 @@ yyreduce: } break; - case 272: + case 282: /* Line 1792 of yacc.c */ -#line 1819 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1875 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6135,9 +6321,9 @@ yyreduce: } break; - case 273: + case 283: /* Line 1792 of yacc.c */ -#line 1824 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1880 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6145,9 +6331,9 @@ yyreduce: } break; - case 274: + case 284: /* Line 1792 of yacc.c */ -#line 1829 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1885 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6155,9 +6341,9 @@ yyreduce: } break; - case 275: + case 285: /* Line 1792 of yacc.c */ -#line 1834 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1890 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6165,9 +6351,9 @@ yyreduce: } break; - case 276: + case 286: /* Line 1792 of yacc.c */ -#line 1839 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1895 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6175,9 +6361,9 @@ yyreduce: } break; - case 277: + case 287: /* Line 1792 of yacc.c */ -#line 1844 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1900 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6185,9 +6371,9 @@ yyreduce: } break; - case 278: + case 288: /* Line 1792 of yacc.c */ -#line 1849 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1905 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6195,9 +6381,9 @@ yyreduce: } break; - case 279: + case 289: /* Line 1792 of yacc.c */ -#line 1854 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1910 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6205,9 +6391,9 @@ yyreduce: } break; - case 280: + case 290: /* Line 1792 of yacc.c */ -#line 1859 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1915 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6215,9 +6401,9 @@ yyreduce: } break; - case 281: + case 291: /* Line 1792 of yacc.c */ -#line 1864 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1920 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6225,9 +6411,9 @@ yyreduce: } break; - case 282: + case 292: /* Line 1792 of yacc.c */ -#line 1869 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1925 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6235,9 +6421,9 @@ yyreduce: } break; - case 283: + case 293: /* Line 1792 of yacc.c */ -#line 1874 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1930 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6245,9 +6431,9 @@ yyreduce: } break; - case 284: + case 294: /* Line 1792 of yacc.c */ -#line 1879 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1935 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6255,9 +6441,9 @@ yyreduce: } break; - case 285: + case 295: /* Line 1792 of yacc.c */ -#line 1884 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1940 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6265,9 +6451,9 @@ yyreduce: } break; - case 286: + case 296: /* Line 1792 of yacc.c */ -#line 1889 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1945 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6275,9 +6461,9 @@ yyreduce: } break; - case 287: + case 297: /* Line 1792 of yacc.c */ -#line 1894 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1950 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6285,9 +6471,9 @@ yyreduce: } break; - case 288: + case 298: /* Line 1792 of yacc.c */ -#line 1899 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1955 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6295,9 +6481,9 @@ yyreduce: } break; - case 289: + case 299: /* Line 1792 of yacc.c */ -#line 1904 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1960 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6305,9 +6491,9 @@ yyreduce: } break; - case 290: + case 300: /* Line 1792 of yacc.c */ -#line 1909 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1965 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6315,9 +6501,9 @@ yyreduce: } break; - case 291: + case 301: /* Line 1792 of yacc.c */ -#line 1914 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1970 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6325,9 +6511,9 @@ yyreduce: } break; - case 292: + case 302: /* Line 1792 of yacc.c */ -#line 1919 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1975 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6335,9 +6521,9 @@ yyreduce: } break; - case 293: + case 303: /* Line 1792 of yacc.c */ -#line 1924 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1980 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6345,9 +6531,9 @@ yyreduce: } break; - case 294: + case 304: /* Line 1792 of yacc.c */ -#line 1929 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1985 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6355,9 +6541,9 @@ yyreduce: } break; - case 295: + case 305: /* Line 1792 of yacc.c */ -#line 1934 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1990 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6365,9 +6551,9 @@ yyreduce: } break; - case 296: + case 306: /* Line 1792 of yacc.c */ -#line 1939 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 1995 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6375,9 +6561,9 @@ yyreduce: } break; - case 297: + case 307: /* Line 1792 of yacc.c */ -#line 1944 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2000 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6385,9 +6571,9 @@ yyreduce: } break; - case 298: + case 308: /* Line 1792 of yacc.c */ -#line 1949 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2005 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6395,9 +6581,9 @@ yyreduce: } break; - case 299: + case 309: /* Line 1792 of yacc.c */ -#line 1954 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2010 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6405,9 +6591,9 @@ yyreduce: } break; - case 300: + case 310: /* Line 1792 of yacc.c */ -#line 1959 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2015 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6415,9 +6601,9 @@ yyreduce: } break; - case 301: + case 311: /* Line 1792 of yacc.c */ -#line 1964 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2020 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6425,9 +6611,9 @@ yyreduce: } break; - case 302: + case 312: /* Line 1792 of yacc.c */ -#line 1969 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2025 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6435,9 +6621,9 @@ yyreduce: } break; - case 303: + case 313: /* Line 1792 of yacc.c */ -#line 1974 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2030 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6445,9 +6631,9 @@ yyreduce: } break; - case 304: + case 314: /* Line 1792 of yacc.c */ -#line 1979 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2035 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6455,9 +6641,9 @@ yyreduce: } break; - case 305: + case 315: /* Line 1792 of yacc.c */ -#line 1984 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2040 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6465,9 +6651,9 @@ yyreduce: } break; - case 306: + case 316: /* Line 1792 of yacc.c */ -#line 1989 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2045 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6475,9 +6661,9 @@ yyreduce: } break; - case 307: + case 317: /* Line 1792 of yacc.c */ -#line 1994 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2050 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6485,9 +6671,9 @@ yyreduce: } break; - case 308: + case 318: /* Line 1792 of yacc.c */ -#line 1999 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2055 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6495,9 +6681,9 @@ yyreduce: } break; - case 309: + case 319: /* Line 1792 of yacc.c */ -#line 2004 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2060 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6505,9 +6691,9 @@ yyreduce: } break; - case 310: + case 320: /* Line 1792 of yacc.c */ -#line 2009 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2065 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6515,9 +6701,9 @@ yyreduce: } break; - case 311: + case 321: /* Line 1792 of yacc.c */ -#line 2014 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2070 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6525,9 +6711,9 @@ yyreduce: } break; - case 312: + case 322: /* Line 1792 of yacc.c */ -#line 2019 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2075 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6535,9 +6721,9 @@ yyreduce: } break; - case 313: + case 323: /* Line 1792 of yacc.c */ -#line 2024 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2080 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6545,9 +6731,9 @@ yyreduce: } break; - case 314: + case 324: /* Line 1792 of yacc.c */ -#line 2029 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2085 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6555,9 +6741,9 @@ yyreduce: } break; - case 315: + case 325: /* Line 1792 of yacc.c */ -#line 2034 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2090 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6565,9 +6751,9 @@ yyreduce: } break; - case 316: + case 326: /* Line 1792 of yacc.c */ -#line 2039 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2095 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6575,9 +6761,9 @@ yyreduce: } break; - case 317: + case 327: /* Line 1792 of yacc.c */ -#line 2044 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2100 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6585,9 +6771,9 @@ yyreduce: } break; - case 318: + case 328: /* Line 1792 of yacc.c */ -#line 2049 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2105 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6595,9 +6781,9 @@ yyreduce: } break; - case 319: + case 329: /* Line 1792 of yacc.c */ -#line 2054 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2110 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6605,9 +6791,9 @@ yyreduce: } break; - case 320: + case 330: /* Line 1792 of yacc.c */ -#line 2059 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2115 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6615,9 +6801,9 @@ yyreduce: } break; - case 321: + case 331: /* Line 1792 of yacc.c */ -#line 2064 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2120 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6625,9 +6811,9 @@ yyreduce: } break; - case 322: + case 332: /* Line 1792 of yacc.c */ -#line 2069 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2125 "glslang.y" { (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6635,9 +6821,9 @@ yyreduce: } break; - case 323: + case 333: /* Line 1792 of yacc.c */ -#line 2074 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2130 "glslang.y" { // GL_OES_EGL_image_external (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; @@ -6646,9 +6832,9 @@ yyreduce: } break; - case 324: + case 334: /* Line 1792 of yacc.c */ -#line 2080 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2136 "glslang.y" { parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -6657,9 +6843,9 @@ yyreduce: } break; - case 325: + case 335: /* Line 1792 of yacc.c */ -#line 2086 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2142 "glslang.y" { parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -6668,9 +6854,9 @@ yyreduce: } break; - case 326: + case 336: /* Line 1792 of yacc.c */ -#line 2092 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2148 "glslang.y" { parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -6679,9 +6865,9 @@ yyreduce: } break; - case 327: + case 337: /* Line 1792 of yacc.c */ -#line 2098 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2154 "glslang.y" { parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -6690,9 +6876,9 @@ yyreduce: } break; - case 328: + case 338: /* Line 1792 of yacc.c */ -#line 2104 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2160 "glslang.y" { parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -6701,9 +6887,9 @@ yyreduce: } break; - case 329: + case 339: /* Line 1792 of yacc.c */ -#line 2110 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2166 "glslang.y" { parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -6712,9 +6898,9 @@ yyreduce: } break; - case 330: + case 340: /* Line 1792 of yacc.c */ -#line 2116 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2172 "glslang.y" { (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type); (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary; @@ -6722,9 +6908,9 @@ yyreduce: } break; - case 331: + case 341: /* Line 1792 of yacc.c */ -#line 2121 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2177 "glslang.y" { // // This is for user defined type names. The lexical phase looked up the @@ -6740,9 +6926,9 @@ yyreduce: } break; - case 332: + case 342: /* Line 1792 of yacc.c */ -#line 2137 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2193 "glslang.y" { parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ENoProfile, 130, 0, "highp precision qualifier"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -6751,9 +6937,9 @@ yyreduce: } break; - case 333: + case 343: /* Line 1792 of yacc.c */ -#line 2143 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2199 "glslang.y" { parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -6762,9 +6948,9 @@ yyreduce: } break; - case 334: + case 344: /* Line 1792 of yacc.c */ -#line 2149 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2205 "glslang.y" { parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier"); (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -6773,15 +6959,15 @@ yyreduce: } break; - case 335: + case 345: /* Line 1792 of yacc.c */ -#line 2158 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2214 "glslang.y" { parseContext.nestedStructCheck((yyvsp[(1) - (3)].lex).loc); } break; - case 336: + case 346: /* Line 1792 of yacc.c */ -#line 2158 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2214 "glslang.y" { TType* structure = new TType((yyvsp[(5) - (6)].interm.typeList), *(yyvsp[(2) - (6)].lex).string); parseContext.structArrayCheck((yyvsp[(2) - (6)].lex).loc, *structure); @@ -6795,15 +6981,15 @@ yyreduce: } break; - case 337: + case 347: /* Line 1792 of yacc.c */ -#line 2169 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2225 "glslang.y" { parseContext.nestedStructCheck((yyvsp[(1) - (2)].lex).loc); } break; - case 338: + case 348: /* Line 1792 of yacc.c */ -#line 2169 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2225 "glslang.y" { TType* structure = new TType((yyvsp[(4) - (5)].interm.typeList), TString("")); (yyval.interm.type).init((yyvsp[(1) - (5)].lex).loc); @@ -6813,17 +6999,17 @@ yyreduce: } break; - case 339: + case 349: /* Line 1792 of yacc.c */ -#line 2179 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2235 "glslang.y" { (yyval.interm.typeList) = (yyvsp[(1) - (1)].interm.typeList); } break; - case 340: + case 350: /* Line 1792 of yacc.c */ -#line 2182 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2238 "glslang.y" { (yyval.interm.typeList) = (yyvsp[(1) - (2)].interm.typeList); for (unsigned int i = 0; i < (yyvsp[(2) - (2)].interm.typeList)->size(); ++i) { @@ -6836,9 +7022,9 @@ yyreduce: } break; - case 341: + case 351: /* Line 1792 of yacc.c */ -#line 2195 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2251 "glslang.y" { if ((yyvsp[(1) - (3)].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[(1) - (3)].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -6859,9 +7045,9 @@ yyreduce: } break; - case 342: + case 352: /* Line 1792 of yacc.c */ -#line 2213 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2269 "glslang.y" { parseContext.globalQualifierFixCheck((yyvsp[(1) - (4)].interm.type).loc, (yyvsp[(1) - (4)].interm.type).qualifier); if ((yyvsp[(2) - (4)].interm.type).arraySizes) { @@ -6885,26 +7071,26 @@ yyreduce: } break; - case 343: + case 353: /* Line 1792 of yacc.c */ -#line 2237 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2293 "glslang.y" { (yyval.interm.typeList) = new TTypeList; (yyval.interm.typeList)->push_back((yyvsp[(1) - (1)].interm.typeLine)); } break; - case 344: + case 354: /* Line 1792 of yacc.c */ -#line 2241 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2297 "glslang.y" { (yyval.interm.typeList)->push_back((yyvsp[(3) - (3)].interm.typeLine)); } break; - case 345: + case 355: /* Line 1792 of yacc.c */ -#line 2247 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2303 "glslang.y" { (yyval.interm.typeLine).type = new TType(EbtVoid); (yyval.interm.typeLine).loc = (yyvsp[(1) - (1)].lex).loc; @@ -6912,9 +7098,9 @@ yyreduce: } break; - case 346: + case 356: /* Line 1792 of yacc.c */ -#line 2252 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2308 "glslang.y" { parseContext.arrayDimCheck((yyvsp[(1) - (2)].lex).loc, (yyvsp[(2) - (2)].interm).arraySizes, 0); @@ -6925,17 +7111,17 @@ yyreduce: } break; - case 347: + case 357: /* Line 1792 of yacc.c */ -#line 2263 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2319 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 348: + case 358: /* Line 1792 of yacc.c */ -#line 2266 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2322 "glslang.y" { const char* initFeature = "{ } style initializers"; parseContext.requireProfile((yyvsp[(1) - (3)].lex).loc, ~EEsProfile, initFeature); @@ -6944,9 +7130,9 @@ yyreduce: } break; - case 349: + case 359: /* Line 1792 of yacc.c */ -#line 2272 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2328 "glslang.y" { const char* initFeature = "{ } style initializers"; parseContext.requireProfile((yyvsp[(1) - (4)].lex).loc, ~EEsProfile, initFeature); @@ -6955,109 +7141,109 @@ yyreduce: } break; - case 350: + case 360: /* Line 1792 of yacc.c */ -#line 2281 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2337 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[(1) - (1)].interm.intermTypedNode), (yyvsp[(1) - (1)].interm.intermTypedNode)->getLoc()); } break; - case 351: + case 361: /* Line 1792 of yacc.c */ -#line 2284 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2340 "glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode)); } break; - case 352: -/* Line 1792 of yacc.c */ -#line 2290 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } - break; - - case 353: -/* Line 1792 of yacc.c */ -#line 2294 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } - break; - - case 354: -/* Line 1792 of yacc.c */ -#line 2295 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } - break; - - case 355: -/* Line 1792 of yacc.c */ -#line 2301 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } - break; - - case 356: -/* Line 1792 of yacc.c */ -#line 2302 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } - break; - - case 357: -/* Line 1792 of yacc.c */ -#line 2303 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } - break; - - case 358: -/* Line 1792 of yacc.c */ -#line 2304 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } - break; - - case 359: -/* Line 1792 of yacc.c */ -#line 2305 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } - break; - - case 360: -/* Line 1792 of yacc.c */ -#line 2306 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } - break; - - case 361: -/* Line 1792 of yacc.c */ -#line 2307 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } - break; - case 362: /* Line 1792 of yacc.c */ -#line 2311 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = 0; } +#line 2346 "glslang.y" + { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } break; case 363: /* Line 1792 of yacc.c */ -#line 2312 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2350 "glslang.y" + { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } + break; + + case 364: +/* Line 1792 of yacc.c */ +#line 2351 "glslang.y" + { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } + break; + + case 365: +/* Line 1792 of yacc.c */ +#line 2357 "glslang.y" + { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } + break; + + case 366: +/* Line 1792 of yacc.c */ +#line 2358 "glslang.y" + { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } + break; + + case 367: +/* Line 1792 of yacc.c */ +#line 2359 "glslang.y" + { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } + break; + + case 368: +/* Line 1792 of yacc.c */ +#line 2360 "glslang.y" + { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } + break; + + case 369: +/* Line 1792 of yacc.c */ +#line 2361 "glslang.y" + { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } + break; + + case 370: +/* Line 1792 of yacc.c */ +#line 2362 "glslang.y" + { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } + break; + + case 371: +/* Line 1792 of yacc.c */ +#line 2363 "glslang.y" + { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } + break; + + case 372: +/* Line 1792 of yacc.c */ +#line 2367 "glslang.y" + { (yyval.interm.intermNode) = 0; } + break; + + case 373: +/* Line 1792 of yacc.c */ +#line 2368 "glslang.y" { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; } break; - case 364: + case 374: /* Line 1792 of yacc.c */ -#line 2316 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2372 "glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; } break; - case 365: + case 375: /* Line 1792 of yacc.c */ -#line 2320 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2376 "glslang.y" { if ((yyvsp[(3) - (5)].interm.intermNode) && (yyvsp[(3) - (5)].interm.intermNode)->getAsAggregate()) (yyvsp[(3) - (5)].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); @@ -7065,38 +7251,38 @@ yyreduce: } break; - case 366: + case 376: /* Line 1792 of yacc.c */ -#line 2328 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2384 "glslang.y" { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } break; - case 367: + case 377: /* Line 1792 of yacc.c */ -#line 2329 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2385 "glslang.y" { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } break; - case 368: + case 378: /* Line 1792 of yacc.c */ -#line 2333 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2389 "glslang.y" { ++parseContext.controlFlowNestingLevel; } break; - case 369: + case 379: /* Line 1792 of yacc.c */ -#line 2336 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2392 "glslang.y" { --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[(2) - (2)].interm.intermNode); } break; - case 370: + case 380: /* Line 1792 of yacc.c */ -#line 2340 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2396 "glslang.y" { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; @@ -7104,9 +7290,9 @@ yyreduce: } break; - case 371: + case 381: /* Line 1792 of yacc.c */ -#line 2345 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2401 "glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; @@ -7115,17 +7301,17 @@ yyreduce: } break; - case 372: + case 382: /* Line 1792 of yacc.c */ -#line 2354 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2410 "glslang.y" { (yyval.interm.intermNode) = 0; } break; - case 373: + case 383: /* Line 1792 of yacc.c */ -#line 2357 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2413 "glslang.y" { if ((yyvsp[(2) - (3)].interm.intermNode) && (yyvsp[(2) - (3)].interm.intermNode)->getAsAggregate()) (yyvsp[(2) - (3)].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); @@ -7133,9 +7319,9 @@ yyreduce: } break; - case 374: + case 384: /* Line 1792 of yacc.c */ -#line 2365 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2421 "glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[(1) - (1)].interm.intermNode)); if ((yyvsp[(1) - (1)].interm.intermNode) && (yyvsp[(1) - (1)].interm.intermNode)->getAsBranchNode() && ((yyvsp[(1) - (1)].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || @@ -7146,9 +7332,9 @@ yyreduce: } break; - case 375: + case 385: /* Line 1792 of yacc.c */ -#line 2373 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2429 "glslang.y" { if ((yyvsp[(2) - (2)].interm.intermNode) && (yyvsp[(2) - (2)].interm.intermNode)->getAsBranchNode() && ((yyvsp[(2) - (2)].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || (yyvsp[(2) - (2)].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) { @@ -7159,57 +7345,57 @@ yyreduce: } break; - case 376: + case 386: /* Line 1792 of yacc.c */ -#line 2384 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2440 "glslang.y" { (yyval.interm.intermNode) = 0; } break; - case 377: + case 387: /* Line 1792 of yacc.c */ -#line 2385 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2441 "glslang.y" { (yyval.interm.intermNode) = static_cast((yyvsp[(1) - (2)].interm.intermTypedNode)); } break; - case 378: + case 388: /* Line 1792 of yacc.c */ -#line 2389 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2445 "glslang.y" { parseContext.boolCheck((yyvsp[(1) - (5)].lex).loc, (yyvsp[(3) - (5)].interm.intermTypedNode)); (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[(3) - (5)].interm.intermTypedNode), (yyvsp[(5) - (5)].interm.nodePair), (yyvsp[(1) - (5)].lex).loc); } break; - case 379: + case 389: /* Line 1792 of yacc.c */ -#line 2396 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2452 "glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[(1) - (3)].interm.intermNode); (yyval.interm.nodePair).node2 = (yyvsp[(3) - (3)].interm.intermNode); } break; - case 380: + case 390: /* Line 1792 of yacc.c */ -#line 2400 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2456 "glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[(1) - (1)].interm.intermNode); (yyval.interm.nodePair).node2 = 0; } break; - case 381: + case 391: /* Line 1792 of yacc.c */ -#line 2408 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2464 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); parseContext.boolCheck((yyvsp[(1) - (1)].interm.intermTypedNode)->getLoc(), (yyvsp[(1) - (1)].interm.intermTypedNode)); } break; - case 382: + case 392: /* Line 1792 of yacc.c */ -#line 2412 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2468 "glslang.y" { parseContext.boolCheck((yyvsp[(2) - (4)].lex).loc, (yyvsp[(1) - (4)].interm.type)); @@ -7222,9 +7408,9 @@ yyreduce: } break; - case 383: + case 393: /* Line 1792 of yacc.c */ -#line 2425 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2481 "glslang.y" { // start new switch sequence on the switch stack ++parseContext.controlFlowNestingLevel; @@ -7235,9 +7421,9 @@ yyreduce: } break; - case 384: + case 394: /* Line 1792 of yacc.c */ -#line 2433 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2489 "glslang.y" { (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[(1) - (8)].lex).loc, (yyvsp[(3) - (8)].interm.intermTypedNode), (yyvsp[(7) - (8)].interm.intermNode) ? (yyvsp[(7) - (8)].interm.intermNode)->getAsAggregate() : 0); delete parseContext.switchSequenceStack.back(); @@ -7249,25 +7435,25 @@ yyreduce: } break; - case 385: + case 395: /* Line 1792 of yacc.c */ -#line 2445 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2501 "glslang.y" { (yyval.interm.intermNode) = 0; } break; - case 386: + case 396: /* Line 1792 of yacc.c */ -#line 2448 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2504 "glslang.y" { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } break; - case 387: + case 397: /* Line 1792 of yacc.c */ -#line 2454 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2510 "glslang.y" { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -7282,9 +7468,9 @@ yyreduce: } break; - case 388: + case 398: /* Line 1792 of yacc.c */ -#line 2466 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2522 "glslang.y" { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -7296,9 +7482,9 @@ yyreduce: } break; - case 389: + case 399: /* Line 1792 of yacc.c */ -#line 2478 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2534 "glslang.y" { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[(1) - (2)].lex).loc, "while loops not available", "limitation", ""); @@ -7309,9 +7495,9 @@ yyreduce: } break; - case 390: + case 400: /* Line 1792 of yacc.c */ -#line 2486 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2542 "glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[(6) - (6)].interm.intermNode), (yyvsp[(4) - (6)].interm.intermTypedNode), 0, true, (yyvsp[(1) - (6)].lex).loc); @@ -7321,9 +7507,9 @@ yyreduce: } break; - case 391: + case 401: /* Line 1792 of yacc.c */ -#line 2493 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2549 "glslang.y" { ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; @@ -7331,9 +7517,9 @@ yyreduce: } break; - case 392: + case 402: /* Line 1792 of yacc.c */ -#line 2498 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2554 "glslang.y" { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[(1) - (8)].lex).loc, "do-while loops not available", "limitation", ""); @@ -7347,9 +7533,9 @@ yyreduce: } break; - case 393: + case 403: /* Line 1792 of yacc.c */ -#line 2509 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2565 "glslang.y" { parseContext.symbolTable.push(); ++parseContext.loopNestingLevel; @@ -7358,9 +7544,9 @@ yyreduce: } break; - case 394: + case 404: /* Line 1792 of yacc.c */ -#line 2515 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2571 "glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[(4) - (7)].interm.intermNode), (yyvsp[(2) - (7)].lex).loc); @@ -7375,59 +7561,59 @@ yyreduce: } break; - case 395: + case 405: /* Line 1792 of yacc.c */ -#line 2530 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2586 "glslang.y" { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } break; - case 396: + case 406: /* Line 1792 of yacc.c */ -#line 2533 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2589 "glslang.y" { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } break; - case 397: + case 407: /* Line 1792 of yacc.c */ -#line 2539 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2595 "glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); } break; - case 398: + case 408: /* Line 1792 of yacc.c */ -#line 2542 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2598 "glslang.y" { (yyval.interm.intermTypedNode) = 0; } break; - case 399: + case 409: /* Line 1792 of yacc.c */ -#line 2548 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2604 "glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[(1) - (2)].interm.intermTypedNode); (yyval.interm.nodePair).node2 = 0; } break; - case 400: + case 410: /* Line 1792 of yacc.c */ -#line 2552 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2608 "glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[(1) - (3)].interm.intermTypedNode); (yyval.interm.nodePair).node2 = (yyvsp[(3) - (3)].interm.intermTypedNode); } break; - case 401: + case 411: /* Line 1792 of yacc.c */ -#line 2559 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2615 "glslang.y" { if (parseContext.loopNestingLevel <= 0) parseContext.error((yyvsp[(1) - (2)].lex).loc, "continue statement only allowed in loops", "", ""); @@ -7435,9 +7621,9 @@ yyreduce: } break; - case 402: + case 412: /* Line 1792 of yacc.c */ -#line 2564 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2620 "glslang.y" { if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0) parseContext.error((yyvsp[(1) - (2)].lex).loc, "break statement only allowed in switch and loops", "", ""); @@ -7445,9 +7631,9 @@ yyreduce: } break; - case 403: + case 413: /* Line 1792 of yacc.c */ -#line 2569 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2625 "glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[(1) - (2)].lex).loc); if (parseContext.currentFunctionType->getBasicType() != EbtVoid) @@ -7457,9 +7643,9 @@ yyreduce: } break; - case 404: + case 414: /* Line 1792 of yacc.c */ -#line 2576 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2632 "glslang.y" { parseContext.functionReturnsValue = true; if (parseContext.currentFunctionType->getBasicType() == EbtVoid) { @@ -7480,61 +7666,61 @@ yyreduce: } break; - case 405: + case 415: /* Line 1792 of yacc.c */ -#line 2594 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2650 "glslang.y" { parseContext.requireStage((yyvsp[(1) - (2)].lex).loc, EShLangFragment, "discard"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[(1) - (2)].lex).loc); } break; - case 406: + case 416: /* Line 1792 of yacc.c */ -#line 2603 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2659 "glslang.y" { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } break; - case 407: + case 417: /* Line 1792 of yacc.c */ -#line 2607 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2663 "glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[(1) - (2)].interm.intermNode), (yyvsp[(2) - (2)].interm.intermNode)); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } break; - case 408: + case 418: /* Line 1792 of yacc.c */ -#line 2614 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2670 "glslang.y" { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } break; - case 409: + case 419: /* Line 1792 of yacc.c */ -#line 2617 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2673 "glslang.y" { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); } break; - case 410: + case 420: /* Line 1792 of yacc.c */ -#line 2623 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2679 "glslang.y" { (yyvsp[(1) - (1)].interm).function = parseContext.handleFunctionDeclarator((yyvsp[(1) - (1)].interm).loc, *(yyvsp[(1) - (1)].interm).function, false /* not prototype */); (yyvsp[(1) - (1)].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[(1) - (1)].interm).loc, *(yyvsp[(1) - (1)].interm).function); } break; - case 411: + case 421: /* Line 1792 of yacc.c */ -#line 2627 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2683 "glslang.y" { // May be best done as post process phase on intermediate code if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue) @@ -7554,7 +7740,7 @@ yyreduce: /* Line 1792 of yacc.c */ -#line 7558 "C:/Projects/glslang/glslang/MachineIndependent/glslang_tab.cpp" +#line 7744 "glslang_tab.cpp" default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -7786,5 +7972,5 @@ yyreturn: /* Line 2055 of yacc.c */ -#line 2644 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 2700 "glslang.y" diff --git a/glslang/MachineIndependent/glslang_tab.cpp.h b/glslang/MachineIndependent/glslang_tab.cpp.h index 0c6ab3bc..03f5706b 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp.h +++ b/glslang/MachineIndependent/glslang_tab.cpp.h @@ -30,8 +30,8 @@ This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ -#ifndef YY_YY_C_PROJECTS_GLSLANG_GLSLANG_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED -# define YY_YY_C_PROJECTS_GLSLANG_GLSLANG_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED +#ifndef YY_YY_GLSLANG_TAB_CPP_H_INCLUDED +# define YY_YY_GLSLANG_TAB_CPP_H_INCLUDED /* Enabling traces. */ #ifndef YYDEBUG # define YYDEBUG 1 @@ -54,255 +54,265 @@ extern int yydebug; DOUBLE = 263, INT = 264, UINT = 265, - BREAK = 266, - CONTINUE = 267, - DO = 268, - ELSE = 269, - FOR = 270, - IF = 271, - DISCARD = 272, - RETURN = 273, - SWITCH = 274, - CASE = 275, - DEFAULT = 276, - SUBROUTINE = 277, - BVEC2 = 278, - BVEC3 = 279, - BVEC4 = 280, - IVEC2 = 281, - IVEC3 = 282, - IVEC4 = 283, - UVEC2 = 284, - UVEC3 = 285, - UVEC4 = 286, - VEC2 = 287, - VEC3 = 288, - VEC4 = 289, - MAT2 = 290, - MAT3 = 291, - MAT4 = 292, - CENTROID = 293, - IN = 294, - OUT = 295, - INOUT = 296, - UNIFORM = 297, - PATCH = 298, - SAMPLE = 299, - BUFFER = 300, - SHARED = 301, - COHERENT = 302, - VOLATILE = 303, - RESTRICT = 304, - READONLY = 305, - WRITEONLY = 306, - DVEC2 = 307, - DVEC3 = 308, - DVEC4 = 309, - DMAT2 = 310, - DMAT3 = 311, - DMAT4 = 312, - NOPERSPECTIVE = 313, - FLAT = 314, - SMOOTH = 315, - LAYOUT = 316, - MAT2X2 = 317, - MAT2X3 = 318, - MAT2X4 = 319, - MAT3X2 = 320, - MAT3X3 = 321, - MAT3X4 = 322, - MAT4X2 = 323, - MAT4X3 = 324, - MAT4X4 = 325, - DMAT2X2 = 326, - DMAT2X3 = 327, - DMAT2X4 = 328, - DMAT3X2 = 329, - DMAT3X3 = 330, - DMAT3X4 = 331, - DMAT4X2 = 332, - DMAT4X3 = 333, - DMAT4X4 = 334, - ATOMIC_UINT = 335, - SAMPLER1D = 336, - SAMPLER2D = 337, - SAMPLER3D = 338, - SAMPLERCUBE = 339, - SAMPLER1DSHADOW = 340, - SAMPLER2DSHADOW = 341, - SAMPLERCUBESHADOW = 342, - SAMPLER1DARRAY = 343, - SAMPLER2DARRAY = 344, - SAMPLER1DARRAYSHADOW = 345, - SAMPLER2DARRAYSHADOW = 346, - ISAMPLER1D = 347, - ISAMPLER2D = 348, - ISAMPLER3D = 349, - ISAMPLERCUBE = 350, - ISAMPLER1DARRAY = 351, - ISAMPLER2DARRAY = 352, - USAMPLER1D = 353, - USAMPLER2D = 354, - USAMPLER3D = 355, - USAMPLERCUBE = 356, - USAMPLER1DARRAY = 357, - USAMPLER2DARRAY = 358, - SAMPLER2DRECT = 359, - SAMPLER2DRECTSHADOW = 360, - ISAMPLER2DRECT = 361, - USAMPLER2DRECT = 362, - SAMPLERBUFFER = 363, - ISAMPLERBUFFER = 364, - USAMPLERBUFFER = 365, - SAMPLERCUBEARRAY = 366, - SAMPLERCUBEARRAYSHADOW = 367, - ISAMPLERCUBEARRAY = 368, - USAMPLERCUBEARRAY = 369, - SAMPLER2DMS = 370, - ISAMPLER2DMS = 371, - USAMPLER2DMS = 372, - SAMPLER2DMSARRAY = 373, - ISAMPLER2DMSARRAY = 374, - USAMPLER2DMSARRAY = 375, - SAMPLEREXTERNALOES = 376, - SAMPLER = 377, - SAMPLERSHADOW = 378, - TEXTURE1D = 379, - TEXTURE2D = 380, - TEXTURE3D = 381, - TEXTURECUBE = 382, - TEXTURE1DARRAY = 383, - TEXTURE2DARRAY = 384, - ITEXTURE1D = 385, - ITEXTURE2D = 386, - ITEXTURE3D = 387, - ITEXTURECUBE = 388, - ITEXTURE1DARRAY = 389, - ITEXTURE2DARRAY = 390, - UTEXTURE1D = 391, - UTEXTURE2D = 392, - UTEXTURE3D = 393, - UTEXTURECUBE = 394, - UTEXTURE1DARRAY = 395, - UTEXTURE2DARRAY = 396, - TEXTURE2DRECT = 397, - ITEXTURE2DRECT = 398, - UTEXTURE2DRECT = 399, - TEXTUREBUFFER = 400, - ITEXTUREBUFFER = 401, - UTEXTUREBUFFER = 402, - TEXTURECUBEARRAY = 403, - ITEXTURECUBEARRAY = 404, - UTEXTURECUBEARRAY = 405, - TEXTURE2DMS = 406, - ITEXTURE2DMS = 407, - UTEXTURE2DMS = 408, - TEXTURE2DMSARRAY = 409, - ITEXTURE2DMSARRAY = 410, - UTEXTURE2DMSARRAY = 411, - SUBPASSINPUT = 412, - SUBPASSINPUTMS = 413, - ISUBPASSINPUT = 414, - ISUBPASSINPUTMS = 415, - USUBPASSINPUT = 416, - USUBPASSINPUTMS = 417, - IMAGE1D = 418, - IIMAGE1D = 419, - UIMAGE1D = 420, - IMAGE2D = 421, - IIMAGE2D = 422, - UIMAGE2D = 423, - IMAGE3D = 424, - IIMAGE3D = 425, - UIMAGE3D = 426, - IMAGE2DRECT = 427, - IIMAGE2DRECT = 428, - UIMAGE2DRECT = 429, - IMAGECUBE = 430, - IIMAGECUBE = 431, - UIMAGECUBE = 432, - IMAGEBUFFER = 433, - IIMAGEBUFFER = 434, - UIMAGEBUFFER = 435, - IMAGE1DARRAY = 436, - IIMAGE1DARRAY = 437, - UIMAGE1DARRAY = 438, - IMAGE2DARRAY = 439, - IIMAGE2DARRAY = 440, - UIMAGE2DARRAY = 441, - IMAGECUBEARRAY = 442, - IIMAGECUBEARRAY = 443, - UIMAGECUBEARRAY = 444, - IMAGE2DMS = 445, - IIMAGE2DMS = 446, - UIMAGE2DMS = 447, - IMAGE2DMSARRAY = 448, - IIMAGE2DMSARRAY = 449, - UIMAGE2DMSARRAY = 450, - STRUCT = 451, - VOID = 452, - WHILE = 453, - IDENTIFIER = 454, - TYPE_NAME = 455, - FLOATCONSTANT = 456, - DOUBLECONSTANT = 457, - INTCONSTANT = 458, - UINTCONSTANT = 459, - BOOLCONSTANT = 460, - LEFT_OP = 461, - RIGHT_OP = 462, - INC_OP = 463, - DEC_OP = 464, - LE_OP = 465, - GE_OP = 466, - EQ_OP = 467, - NE_OP = 468, - AND_OP = 469, - OR_OP = 470, - XOR_OP = 471, - MUL_ASSIGN = 472, - DIV_ASSIGN = 473, - ADD_ASSIGN = 474, - MOD_ASSIGN = 475, - LEFT_ASSIGN = 476, - RIGHT_ASSIGN = 477, - AND_ASSIGN = 478, - XOR_ASSIGN = 479, - OR_ASSIGN = 480, - SUB_ASSIGN = 481, - LEFT_PAREN = 482, - RIGHT_PAREN = 483, - LEFT_BRACKET = 484, - RIGHT_BRACKET = 485, - LEFT_BRACE = 486, - RIGHT_BRACE = 487, - DOT = 488, - COMMA = 489, - COLON = 490, - EQUAL = 491, - SEMICOLON = 492, - BANG = 493, - DASH = 494, - TILDE = 495, - PLUS = 496, - STAR = 497, - SLASH = 498, - PERCENT = 499, - LEFT_ANGLE = 500, - RIGHT_ANGLE = 501, - VERTICAL_BAR = 502, - CARET = 503, - AMPERSAND = 504, - QUESTION = 505, - INVARIANT = 506, - PRECISE = 507, - HIGH_PRECISION = 508, - MEDIUM_PRECISION = 509, - LOW_PRECISION = 510, - PRECISION = 511, - PACKED = 512, - RESOURCE = 513, - SUPERP = 514 + INT64_T = 266, + UINT64_T = 267, + BREAK = 268, + CONTINUE = 269, + DO = 270, + ELSE = 271, + FOR = 272, + IF = 273, + DISCARD = 274, + RETURN = 275, + SWITCH = 276, + CASE = 277, + DEFAULT = 278, + SUBROUTINE = 279, + BVEC2 = 280, + BVEC3 = 281, + BVEC4 = 282, + IVEC2 = 283, + IVEC3 = 284, + IVEC4 = 285, + I64VEC2 = 286, + I64VEC3 = 287, + I64VEC4 = 288, + UVEC2 = 289, + UVEC3 = 290, + UVEC4 = 291, + U64VEC2 = 292, + U64VEC3 = 293, + U64VEC4 = 294, + VEC2 = 295, + VEC3 = 296, + VEC4 = 297, + MAT2 = 298, + MAT3 = 299, + MAT4 = 300, + CENTROID = 301, + IN = 302, + OUT = 303, + INOUT = 304, + UNIFORM = 305, + PATCH = 306, + SAMPLE = 307, + BUFFER = 308, + SHARED = 309, + COHERENT = 310, + VOLATILE = 311, + RESTRICT = 312, + READONLY = 313, + WRITEONLY = 314, + DVEC2 = 315, + DVEC3 = 316, + DVEC4 = 317, + DMAT2 = 318, + DMAT3 = 319, + DMAT4 = 320, + NOPERSPECTIVE = 321, + FLAT = 322, + SMOOTH = 323, + LAYOUT = 324, + MAT2X2 = 325, + MAT2X3 = 326, + MAT2X4 = 327, + MAT3X2 = 328, + MAT3X3 = 329, + MAT3X4 = 330, + MAT4X2 = 331, + MAT4X3 = 332, + MAT4X4 = 333, + DMAT2X2 = 334, + DMAT2X3 = 335, + DMAT2X4 = 336, + DMAT3X2 = 337, + DMAT3X3 = 338, + DMAT3X4 = 339, + DMAT4X2 = 340, + DMAT4X3 = 341, + DMAT4X4 = 342, + ATOMIC_UINT = 343, + SAMPLER1D = 344, + SAMPLER2D = 345, + SAMPLER3D = 346, + SAMPLERCUBE = 347, + SAMPLER1DSHADOW = 348, + SAMPLER2DSHADOW = 349, + SAMPLERCUBESHADOW = 350, + SAMPLER1DARRAY = 351, + SAMPLER2DARRAY = 352, + SAMPLER1DARRAYSHADOW = 353, + SAMPLER2DARRAYSHADOW = 354, + ISAMPLER1D = 355, + ISAMPLER2D = 356, + ISAMPLER3D = 357, + ISAMPLERCUBE = 358, + ISAMPLER1DARRAY = 359, + ISAMPLER2DARRAY = 360, + USAMPLER1D = 361, + USAMPLER2D = 362, + USAMPLER3D = 363, + USAMPLERCUBE = 364, + USAMPLER1DARRAY = 365, + USAMPLER2DARRAY = 366, + SAMPLER2DRECT = 367, + SAMPLER2DRECTSHADOW = 368, + ISAMPLER2DRECT = 369, + USAMPLER2DRECT = 370, + SAMPLERBUFFER = 371, + ISAMPLERBUFFER = 372, + USAMPLERBUFFER = 373, + SAMPLERCUBEARRAY = 374, + SAMPLERCUBEARRAYSHADOW = 375, + ISAMPLERCUBEARRAY = 376, + USAMPLERCUBEARRAY = 377, + SAMPLER2DMS = 378, + ISAMPLER2DMS = 379, + USAMPLER2DMS = 380, + SAMPLER2DMSARRAY = 381, + ISAMPLER2DMSARRAY = 382, + USAMPLER2DMSARRAY = 383, + SAMPLEREXTERNALOES = 384, + SAMPLER = 385, + SAMPLERSHADOW = 386, + TEXTURE1D = 387, + TEXTURE2D = 388, + TEXTURE3D = 389, + TEXTURECUBE = 390, + TEXTURE1DARRAY = 391, + TEXTURE2DARRAY = 392, + ITEXTURE1D = 393, + ITEXTURE2D = 394, + ITEXTURE3D = 395, + ITEXTURECUBE = 396, + ITEXTURE1DARRAY = 397, + ITEXTURE2DARRAY = 398, + UTEXTURE1D = 399, + UTEXTURE2D = 400, + UTEXTURE3D = 401, + UTEXTURECUBE = 402, + UTEXTURE1DARRAY = 403, + UTEXTURE2DARRAY = 404, + TEXTURE2DRECT = 405, + ITEXTURE2DRECT = 406, + UTEXTURE2DRECT = 407, + TEXTUREBUFFER = 408, + ITEXTUREBUFFER = 409, + UTEXTUREBUFFER = 410, + TEXTURECUBEARRAY = 411, + ITEXTURECUBEARRAY = 412, + UTEXTURECUBEARRAY = 413, + TEXTURE2DMS = 414, + ITEXTURE2DMS = 415, + UTEXTURE2DMS = 416, + TEXTURE2DMSARRAY = 417, + ITEXTURE2DMSARRAY = 418, + UTEXTURE2DMSARRAY = 419, + SUBPASSINPUT = 420, + SUBPASSINPUTMS = 421, + ISUBPASSINPUT = 422, + ISUBPASSINPUTMS = 423, + USUBPASSINPUT = 424, + USUBPASSINPUTMS = 425, + IMAGE1D = 426, + IIMAGE1D = 427, + UIMAGE1D = 428, + IMAGE2D = 429, + IIMAGE2D = 430, + UIMAGE2D = 431, + IMAGE3D = 432, + IIMAGE3D = 433, + UIMAGE3D = 434, + IMAGE2DRECT = 435, + IIMAGE2DRECT = 436, + UIMAGE2DRECT = 437, + IMAGECUBE = 438, + IIMAGECUBE = 439, + UIMAGECUBE = 440, + IMAGEBUFFER = 441, + IIMAGEBUFFER = 442, + UIMAGEBUFFER = 443, + IMAGE1DARRAY = 444, + IIMAGE1DARRAY = 445, + UIMAGE1DARRAY = 446, + IMAGE2DARRAY = 447, + IIMAGE2DARRAY = 448, + UIMAGE2DARRAY = 449, + IMAGECUBEARRAY = 450, + IIMAGECUBEARRAY = 451, + UIMAGECUBEARRAY = 452, + IMAGE2DMS = 453, + IIMAGE2DMS = 454, + UIMAGE2DMS = 455, + IMAGE2DMSARRAY = 456, + IIMAGE2DMSARRAY = 457, + UIMAGE2DMSARRAY = 458, + STRUCT = 459, + VOID = 460, + WHILE = 461, + IDENTIFIER = 462, + TYPE_NAME = 463, + FLOATCONSTANT = 464, + DOUBLECONSTANT = 465, + INTCONSTANT = 466, + UINTCONSTANT = 467, + INT64CONSTANT = 468, + UINT64CONSTANT = 469, + BOOLCONSTANT = 470, + LEFT_OP = 471, + RIGHT_OP = 472, + INC_OP = 473, + DEC_OP = 474, + LE_OP = 475, + GE_OP = 476, + EQ_OP = 477, + NE_OP = 478, + AND_OP = 479, + OR_OP = 480, + XOR_OP = 481, + MUL_ASSIGN = 482, + DIV_ASSIGN = 483, + ADD_ASSIGN = 484, + MOD_ASSIGN = 485, + LEFT_ASSIGN = 486, + RIGHT_ASSIGN = 487, + AND_ASSIGN = 488, + XOR_ASSIGN = 489, + OR_ASSIGN = 490, + SUB_ASSIGN = 491, + LEFT_PAREN = 492, + RIGHT_PAREN = 493, + LEFT_BRACKET = 494, + RIGHT_BRACKET = 495, + LEFT_BRACE = 496, + RIGHT_BRACE = 497, + DOT = 498, + COMMA = 499, + COLON = 500, + EQUAL = 501, + SEMICOLON = 502, + BANG = 503, + DASH = 504, + TILDE = 505, + PLUS = 506, + STAR = 507, + SLASH = 508, + PERCENT = 509, + LEFT_ANGLE = 510, + RIGHT_ANGLE = 511, + VERTICAL_BAR = 512, + CARET = 513, + AMPERSAND = 514, + QUESTION = 515, + INVARIANT = 516, + PRECISE = 517, + HIGH_PRECISION = 518, + MEDIUM_PRECISION = 519, + LOW_PRECISION = 520, + PRECISION = 521, + PACKED = 522, + RESOURCE = 523, + SUPERP = 524 }; #endif @@ -311,7 +321,7 @@ extern int yydebug; typedef union YYSTYPE { /* Line 2058 of yacc.c */ -#line 66 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y" +#line 66 "glslang.y" struct { glslang::TSourceLoc loc; @@ -319,6 +329,8 @@ typedef union YYSTYPE glslang::TString *string; int i; unsigned int u; + long long i64; + unsigned long long u64; bool b; double d; }; @@ -345,7 +357,7 @@ typedef union YYSTYPE /* Line 2058 of yacc.c */ -#line 349 "C:/Projects/glslang/glslang/MachineIndependent/glslang_tab.cpp.h" +#line 361 "glslang_tab.cpp.h" } YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ @@ -367,4 +379,4 @@ int yyparse (); #endif #endif /* ! YYPARSE_PARAM */ -#endif /* !YY_YY_C_PROJECTS_GLSLANG_GLSLANG_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED */ +#endif /* !YY_YY_GLSLANG_TAB_CPP_H_INCLUDED */ diff --git a/glslang/MachineIndependent/intermOut.cpp b/glslang/MachineIndependent/intermOut.cpp index eb6c30cd..82e71600 100644 --- a/glslang/MachineIndependent/intermOut.cpp +++ b/glslang/MachineIndependent/intermOut.cpp @@ -206,22 +206,44 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node) case EOpConvUintToBool: out.debug << "Convert uint to bool"; break; case EOpConvFloatToBool: out.debug << "Convert float to bool"; break; case EOpConvDoubleToBool: out.debug << "Convert double to bool"; break; + case EOpConvInt64ToBool: out.debug << "Convert int64 to bool"; break; + case EOpConvUint64ToBool: out.debug << "Convert uint64 to bool"; break; case EOpConvIntToFloat: out.debug << "Convert int to float"; break; case EOpConvUintToFloat: out.debug << "Convert uint to float"; break; case EOpConvDoubleToFloat: out.debug << "Convert double to float"; break; + case EOpConvInt64ToFloat: out.debug << "Convert int64 to float"; break; + case EOpConvUint64ToFloat: out.debug << "Convert uint64 to float"; break; case EOpConvBoolToFloat: out.debug << "Convert bool to float"; break; case EOpConvUintToInt: out.debug << "Convert uint to int"; break; case EOpConvFloatToInt: out.debug << "Convert float to int"; break; case EOpConvDoubleToInt: out.debug << "Convert double to int"; break; case EOpConvBoolToInt: out.debug << "Convert bool to int"; break; + case EOpConvInt64ToInt: out.debug << "Convert int64 to int"; break; + case EOpConvUint64ToInt: out.debug << "Convert uint64 to int"; break; case EOpConvIntToUint: out.debug << "Convert int to uint"; break; case EOpConvFloatToUint: out.debug << "Convert float to uint"; break; case EOpConvDoubleToUint: out.debug << "Convert double to uint"; break; case EOpConvBoolToUint: out.debug << "Convert bool to uint"; break; + case EOpConvInt64ToUint: out.debug << "Convert int64 to uint"; break; + case EOpConvUint64ToUint: out.debug << "Convert uint64 to uint"; break; case EOpConvIntToDouble: out.debug << "Convert int to double"; break; case EOpConvUintToDouble: out.debug << "Convert uint to double"; break; case EOpConvFloatToDouble: out.debug << "Convert float to double"; break; case EOpConvBoolToDouble: out.debug << "Convert bool to double"; break; + case EOpConvInt64ToDouble: out.debug << "Convert int64 to double"; break; + case EOpConvUint64ToDouble: out.debug << "Convert uint64 to double"; break; + case EOpConvBoolToInt64: out.debug << "Convert bool to int64"; break; + case EOpConvIntToInt64: out.debug << "Convert int to int64"; break; + case EOpConvUintToInt64: out.debug << "Convert uint to int64"; break; + case EOpConvFloatToInt64: out.debug << "Convert float to int64"; break; + case EOpConvDoubleToInt64: out.debug << "Convert double to int64"; break; + case EOpConvUint64ToInt64: out.debug << "Convert uint64 to int64"; break; + case EOpConvBoolToUint64: out.debug << "Convert bool to uint64"; break; + case EOpConvIntToUint64: out.debug << "Convert int to uint64"; break; + case EOpConvUintToUint64: out.debug << "Convert uint to uint64"; break; + case EOpConvFloatToUint64: out.debug << "Convert float to uint64"; break; + case EOpConvDoubleToUint64: out.debug << "Convert double to uint64"; break; + case EOpConvInt64ToUint64: out.debug << "Convert uint64 to uint64"; break; case EOpRadians: out.debug << "radians"; break; case EOpDegrees: out.debug << "degrees"; break; @@ -261,6 +283,10 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node) case EOpFloatBitsToUint:out.debug << "floatBitsToUint"; break; case EOpIntBitsToFloat: out.debug << "intBitsToFloat"; break; case EOpUintBitsToFloat:out.debug << "uintBitsToFloat"; break; + case EOpDoubleBitsToInt64: out.debug << "doubleBitsToInt64"; break; + case EOpDoubleBitsToUint64: out.debug << "doubleBitsToUint64"; break; + case EOpInt64BitsToDouble: out.debug << "int64BitsToDouble"; break; + case EOpUint64BitsToDouble: out.debug << "uint64BitsToDouble"; break; case EOpPackSnorm2x16: out.debug << "packSnorm2x16"; break; case EOpUnpackSnorm2x16:out.debug << "unpackSnorm2x16"; break; case EOpPackUnorm2x16: out.debug << "packUnorm2x16"; break; @@ -275,6 +301,11 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node) case EOpPackDouble2x32: out.debug << "PackDouble2x32"; break; case EOpUnpackDouble2x32: out.debug << "UnpackDouble2x32"; break; + case EOpPackInt2x32: out.debug << "packInt2x32"; break; + case EOpUnpackInt2x32: out.debug << "unpackInt2x32"; break; + case EOpPackUint2x32: out.debug << "packUint2x32"; break; + case EOpUnpackUint2x32: out.debug << "unpackUint2x32"; break; + case EOpLength: out.debug << "length"; break; case EOpNormalize: out.debug << "normalize"; break; case EOpDPdx: out.debug << "dPdx"; break; @@ -366,6 +397,14 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpConstructUVec2: out.debug << "Construct uvec2"; break; case EOpConstructUVec3: out.debug << "Construct uvec3"; break; case EOpConstructUVec4: out.debug << "Construct uvec4"; break; + case EOpConstructInt64: out.debug << "Construct int64_t"; break; + case EOpConstructI64Vec2: out.debug << "Construct i64vec2"; break; + case EOpConstructI64Vec3: out.debug << "Construct i64vec3"; break; + case EOpConstructI64Vec4: out.debug << "Construct i64vec4"; break; + case EOpConstructUint64: out.debug << "Construct uint64_t"; break; + case EOpConstructU64Vec2: out.debug << "Construct u64vec2"; break; + case EOpConstructU64Vec3: out.debug << "Construct u64vec3"; break; + case EOpConstructU64Vec4: out.debug << "Construct u64vec4"; break; case EOpConstructMat2x2: out.debug << "Construct mat2"; break; case EOpConstructMat2x3: out.debug << "Construct mat2x3"; break; case EOpConstructMat2x4: out.debug << "Construct mat2x4"; break; @@ -582,6 +621,24 @@ static void OutputConstantUnion(TInfoSink& out, const TIntermTyped* node, const out.debug << buf << "\n"; } break; + case EbtInt64: + { + const int maxSize = 300; + char buf[maxSize]; + snprintf(buf, maxSize, "%lld (%s)", constUnion[i].getI64Const(), "const int64_t"); + + out.debug << buf << "\n"; + } + break; + case EbtUint64: + { + const int maxSize = 300; + char buf[maxSize]; + snprintf(buf, maxSize, "%llu (%s)", constUnion[i].getU64Const(), "const uint64_t"); + + out.debug << buf << "\n"; + } + break; default: out.info.message(EPrefixInternalError, "Unknown constant", node->getLoc()); break; diff --git a/glslang/MachineIndependent/linkValidate.cpp b/glslang/MachineIndependent/linkValidate.cpp index ef9daa87..f82ca21b 100644 --- a/glslang/MachineIndependent/linkValidate.cpp +++ b/glslang/MachineIndependent/linkValidate.cpp @@ -880,6 +880,8 @@ const int baseAlignmentVec4Std140 = 16; int TIntermediate::getBaseAlignmentScalar(const TType& type, int& size) { switch (type.getBasicType()) { + case EbtInt64: + case EbtUint64: case EbtDouble: size = 8; return 8; default: size = 4; return 4; } diff --git a/glslang/MachineIndependent/localintermediate.h b/glslang/MachineIndependent/localintermediate.h index c2d0c74a..17b7d21c 100644 --- a/glslang/MachineIndependent/localintermediate.h +++ b/glslang/MachineIndependent/localintermediate.h @@ -191,6 +191,8 @@ public: TIntermConstantUnion* addConstantUnion(const TConstUnionArray&, const TType&, const TSourceLoc&, bool literal = false) const; TIntermConstantUnion* addConstantUnion(int, const TSourceLoc&, bool literal = false) const; 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; TIntermConstantUnion* addConstantUnion(bool, const TSourceLoc&, bool literal = false) const; TIntermConstantUnion* addConstantUnion(double, TBasicType, const TSourceLoc&, bool literal = false) const; TIntermTyped* promoteConstantUnion(TBasicType, TIntermConstantUnion*) const; diff --git a/glslang/MachineIndependent/parseVersions.h b/glslang/MachineIndependent/parseVersions.h index c9dfdc91..13d76805 100755 --- a/glslang/MachineIndependent/parseVersions.h +++ b/glslang/MachineIndependent/parseVersions.h @@ -76,6 +76,7 @@ public: virtual void updateExtensionBehavior(int line, const char* const extension, const char* behavior); virtual void fullIntegerCheck(const TSourceLoc&, const char* op); virtual void doubleCheck(const TSourceLoc&, const char* op); + virtual void int64Check(const TSourceLoc&, const char* op, bool builtIn = false); virtual void spvRemoved(const TSourceLoc&, const char* op); virtual void vulkanRemoved(const TSourceLoc&, const char* op); virtual void requireVulkan(const TSourceLoc&, const char* op); diff --git a/glslang/MachineIndependent/preprocessor/Pp.cpp b/glslang/MachineIndependent/preprocessor/Pp.cpp index b9d00c8e..35097588 100644 --- a/glslang/MachineIndependent/preprocessor/Pp.cpp +++ b/glslang/MachineIndependent/preprocessor/Pp.cpp @@ -705,7 +705,8 @@ int TPpContext::CPPerror(TPpToken* ppToken) TSourceLoc loc = ppToken->loc; while (token != '\n' && token != EndOfInput) { - if (token == PpAtomConstInt || token == PpAtomConstUint || + if (token == PpAtomConstInt || token == PpAtomConstUint || + token == PpAtomConstInt64 || token == PpAtomConstUint64 || token == PpAtomConstFloat || token == PpAtomConstDouble) { message.append(ppToken->name); } else if (token == PpAtomIdentifier || token == PpAtomConstString) { @@ -736,6 +737,8 @@ int TPpContext::CPPpragma(TPpToken* ppToken) case PpAtomIdentifier: case PpAtomConstInt: case PpAtomConstUint: + case PpAtomConstInt64: + case PpAtomConstUint64: case PpAtomConstFloat: case PpAtomConstDouble: tokens.push_back(ppToken->name); diff --git a/glslang/MachineIndependent/preprocessor/PpContext.h b/glslang/MachineIndependent/preprocessor/PpContext.h index f65eb603..4e47fa05 100644 --- a/glslang/MachineIndependent/preprocessor/PpContext.h +++ b/glslang/MachineIndependent/preprocessor/PpContext.h @@ -111,6 +111,7 @@ public: bool space; // true if a space (for white space or a removed comment) should also be recognized, in front of the token returned int ival; double dval; + long long i64val; int atom; char name[MaxTokenLength + 1]; }; diff --git a/glslang/MachineIndependent/preprocessor/PpScanner.cpp b/glslang/MachineIndependent/preprocessor/PpScanner.cpp index 719365d4..b3d1af6d 100644 --- a/glslang/MachineIndependent/preprocessor/PpScanner.cpp +++ b/glslang/MachineIndependent/preprocessor/PpScanner.cpp @@ -238,9 +238,11 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) int len = 0; int ch = 0; int ii = 0; - unsigned ival = 0; + unsigned long long ival = 0; + bool enableInt64 = pp->parseContext.version >= 450 && pp->parseContext.extensionTurnedOn(E_GL_ARB_gpu_shader_int64); ppToken->ival = 0; + ppToken->i64val = 0; ppToken->space = false; ch = getch(); for (;;) { @@ -299,6 +301,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) // must be hexidecimal bool isUnsigned = false; + bool isInt64 = false; ppToken->name[len++] = (char)ch; ch = getch(); if ((ch >= '0' && ch <= '9') || @@ -307,7 +310,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) ival = 0; do { - if (ival <= 0x0fffffff) { + if (ival <= 0x0fffffff || (enableInt64 && ival <= 0x0fffffffffffffffull)) { ppToken->name[len++] = (char)ch; if (ch >= '0' && ch <= '9') { ii = ch - '0'; @@ -323,7 +326,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) pp->parseContext.ppError(ppToken->loc, "hexidecimal literal too big", "", ""); AlreadyComplained = 1; } - ival = 0xffffffff; + ival = 0xffffffffffffffffull; } ch = getch(); } while ((ch >= '0' && ch <= '9') || @@ -336,19 +339,37 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; isUnsigned = true; + + if (enableInt64) { + int nextCh = getch(); + if ((ch == 'u' && nextCh == 'l') || (ch == 'U' && nextCh == 'L')) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)nextCh; + isInt64 = true; + } else + ungetch(); + } + } + else if (enableInt64 && (ch == 'l' || ch == 'L')) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)ch; + isInt64 = true; } else ungetch(); ppToken->name[len] = '\0'; - ppToken->ival = (int)ival; - if (isUnsigned) - return PpAtomConstUint; - else - return PpAtomConstInt; + if (isInt64) { + ppToken->i64val = ival; + return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64; + } else { + ppToken->ival = (int)ival; + return isUnsigned ? PpAtomConstUint : PpAtomConstInt; + } } else { // could be octal integer or floating point, speculative pursue octal until it must be floating point bool isUnsigned = false; + bool isInt64 = false; bool octalOverflow = false; bool nonOctal = false; ival = 0; @@ -361,7 +382,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) pp->parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); AlreadyComplained = 1; } - if (ival <= 0x1fffffff) { + if (ival <= 0x1fffffff || (enableInt64 && ival <= 0x1fffffffffffffffull)) { ii = ch - '0'; ival = (ival << 3) | ii; } else @@ -382,7 +403,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) ch = getch(); } while (ch >= '0' && ch <= '9'); } - if (ch == '.' || ch == 'e' || ch == 'f' || ch == 'E' || ch == 'F' || ch == 'l' || ch == 'L') + if (ch == '.' || ch == 'e' || ch == 'f' || ch == 'E' || ch == 'F') return pp->lFloatConst(len, ch, ppToken); // wasn't a float, so must be octal... @@ -393,6 +414,21 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; isUnsigned = true; + + if (enableInt64) { + int nextCh = getch(); + if ((ch == 'u' && nextCh == 'l') || (ch == 'U' && nextCh == 'L')) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)nextCh; + isInt64 = true; + } else + ungetch(); + } + } + else if (enableInt64 && (ch == 'l' || ch == 'L')) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)ch; + isInt64 = true; } else ungetch(); ppToken->name[len] = '\0'; @@ -400,12 +436,13 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) if (octalOverflow) pp->parseContext.ppError(ppToken->loc, "octal literal too big", "", ""); - ppToken->ival = (int)ival; - - if (isUnsigned) - return PpAtomConstUint; - else - return PpAtomConstInt; + if (isInt64) { + ppToken->i64val = ival; + return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64; + } else { + ppToken->ival = (int)ival; + return isUnsigned ? PpAtomConstUint : PpAtomConstInt; + } } break; case '1': case '2': case '3': case '4': @@ -421,16 +458,31 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) } ch = getch(); } while (ch >= '0' && ch <= '9'); - if (ch == '.' || ch == 'e' || ch == 'f' || ch == 'E' || ch == 'F' || ch == 'l' || ch == 'L') { + if (ch == '.' || ch == 'e' || ch == 'f' || ch == 'E' || ch == 'F') { return pp->lFloatConst(len, ch, ppToken); } else { // Finish handling signed and unsigned integers int numericLen = len; - bool uint = false; + bool isUnsigned = false; + bool isInt64 = false; if (ch == 'u' || ch == 'U') { if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; - uint = true; + isUnsigned = true; + + if (enableInt64) { + int nextCh = getch(); + if ((ch == 'u' && nextCh == 'l') || (ch == 'U' && nextCh == 'L')) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)nextCh; + isInt64 = true; + } else + ungetch(); + } + } else if (enableInt64 && (ch == 'l' || ch == 'L')) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)ch; + isInt64 = true; } else ungetch(); @@ -438,21 +490,26 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) ival = 0; const unsigned oneTenthMaxInt = 0xFFFFFFFFu / 10; const unsigned remainderMaxInt = 0xFFFFFFFFu - 10 * oneTenthMaxInt; + const unsigned long long oneTenthMaxInt64 = 0xFFFFFFFFFFFFFFFFull / 10; + const unsigned long long remainderMaxInt64 = 0xFFFFFFFFFFFFFFFFull - 10 * oneTenthMaxInt64; for (int i = 0; i < numericLen; i++) { ch = ppToken->name[i] - '0'; - if ((ival > oneTenthMaxInt) || (ival == oneTenthMaxInt && (unsigned)ch > remainderMaxInt)) { + if ((enableInt64 == false && ((ival > oneTenthMaxInt) || (ival == oneTenthMaxInt && (unsigned)ch > remainderMaxInt))) || + (enableInt64 && ((ival > oneTenthMaxInt64) || (ival == oneTenthMaxInt64 && (unsigned long long)ch > remainderMaxInt64)))) { pp->parseContext.ppError(ppToken->loc, "numeric literal too big", "", ""); - ival = 0xFFFFFFFFu; + ival = 0xFFFFFFFFFFFFFFFFull; break; } else ival = ival * 10 + ch; } - ppToken->ival = (int)ival; - if (uint) - return PpAtomConstUint; - else - return PpAtomConstInt; + if (isInt64) { + ppToken->i64val = ival; + return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64; + } else { + ppToken->ival = (int)ival; + return isUnsigned ? PpAtomConstUint : PpAtomConstInt; + } } break; case '-': @@ -686,6 +743,8 @@ const char* TPpContext::tokenize(TPpToken* ppToken) case PpAtomConstInt: case PpAtomConstUint: case PpAtomConstFloat: + case PpAtomConstInt64: + case PpAtomConstUint64: case PpAtomConstDouble: tokenString = ppToken->name; break; diff --git a/glslang/MachineIndependent/preprocessor/PpTokens.cpp b/glslang/MachineIndependent/preprocessor/PpTokens.cpp index 52343b7c..95da3dbd 100644 --- a/glslang/MachineIndependent/preprocessor/PpTokens.cpp +++ b/glslang/MachineIndependent/preprocessor/PpTokens.cpp @@ -141,6 +141,8 @@ void TPpContext::RecordToken(TokenStream *pTok, int token, TPpToken* ppToken) break; case PpAtomConstInt: case PpAtomConstUint: + case PpAtomConstInt64: + case PpAtomConstUint64: case PpAtomConstFloat: case PpAtomConstDouble: str = ppToken->name; @@ -193,6 +195,8 @@ int TPpContext::ReadToken(TokenStream *pTok, TPpToken *ppToken) case PpAtomConstDouble: case PpAtomConstInt: case PpAtomConstUint: + case PpAtomConstInt64: + case PpAtomConstUint64: len = 0; ch = lReadByte(pTok); while (ch != 0 && ch != EndOfInput) { @@ -227,6 +231,16 @@ int TPpContext::ReadToken(TokenStream *pTok, TPpToken *ppToken) } else ppToken->ival = atoi(ppToken->name); break; + case PpAtomConstInt64: + case PpAtomConstUint64: + if (len > 0 && tokenText[0] == '0') { + if (len > 1 && (tokenText[1] == 'x' || tokenText[1] == 'X')) + ppToken->i64val = std::stoll(ppToken->name, 0, 16); + else + ppToken->i64val = std::stoll(ppToken->name, 0, 8); + } else + ppToken->i64val = std::stoll(ppToken->name); + break; } } diff --git a/glslang/MachineIndependent/preprocessor/PpTokens.h b/glslang/MachineIndependent/preprocessor/PpTokens.h index 391b04ad..87f0eb1a 100644 --- a/glslang/MachineIndependent/preprocessor/PpTokens.h +++ b/glslang/MachineIndependent/preprocessor/PpTokens.h @@ -119,6 +119,8 @@ enum EFixedAtoms { PpAtomConstInt, PpAtomConstUint, + PpAtomConstInt64, + PpAtomConstUint64, PpAtomConstFloat, PpAtomConstDouble, PpAtomConstString, diff --git a/glslang/MachineIndependent/reflection.cpp b/glslang/MachineIndependent/reflection.cpp index 9ef6d02f..19e08e16 100644 --- a/glslang/MachineIndependent/reflection.cpp +++ b/glslang/MachineIndependent/reflection.cpp @@ -540,6 +540,8 @@ public: case EbtDouble: return GL_DOUBLE_VEC2 + offset; case EbtInt: return GL_INT_VEC2 + offset; case EbtUint: return GL_UNSIGNED_INT_VEC2 + offset; + case EbtInt64: return GL_INT64_ARB + offset; + case EbtUint64: return GL_UNSIGNED_INT64_ARB + offset; case EbtBool: return GL_BOOL_VEC2 + offset; case EbtAtomicUint: return GL_UNSIGNED_INT_ATOMIC_COUNTER + offset; default: return 0; @@ -605,6 +607,8 @@ public: case EbtDouble: return GL_DOUBLE; case EbtInt: return GL_INT; case EbtUint: return GL_UNSIGNED_INT; + case EbtInt64: return GL_INT64_ARB; + case EbtUint64: return GL_UNSIGNED_INT64_ARB; case EbtBool: return GL_BOOL; case EbtAtomicUint: return GL_UNSIGNED_INT_ATOMIC_COUNTER; default: return 0; diff --git a/gtests/Spv.FromFile.cpp b/gtests/Spv.FromFile.cpp index 9cd0787a..e5040b22 100644 --- a/gtests/Spv.FromFile.cpp +++ b/gtests/Spv.FromFile.cpp @@ -119,6 +119,7 @@ INSTANTIATE_TEST_CASE_P( "spv.functionCall.frag", "spv.functionSemantics.frag", "spv.interpOps.frag", + "spv.int64.frag", "spv.layoutNested.vert", "spv.length.frag", "spv.localAggregates.frag",