From 3c3669904c4e6816974293ae9301f24de22ea336 Mon Sep 17 00:00:00 2001 From: Chao Chen Date: Wed, 19 Sep 2018 11:41:59 -0700 Subject: [PATCH] Add-support-for-SPV_NV_mesh_shader --- SPIRV/GLSL.ext.NV.h | 5 +- SPIRV/GlslangToSpv.cpp | 146 +- SPIRV/disassemble.cpp | 44 +- SPIRV/doc.cpp | 32 +- StandAlone/ResourceLimits.cpp | 44 +- StandAlone/StandAlone.cpp | 14 + .../spv.meshShaderBuiltins.mesh.out | 259 + .../spv.meshShaderPerViewBuiltins.mesh.out | 212 + .../spv.meshShaderPerViewUserDefined.mesh.out | 156 + .../spv.meshShaderSharedMem.mesh.out | 128 + .../spv.meshShaderTaskMem.mesh.out | 107 + .../spv.meshShaderUserDefined.mesh.out | 203 + Test/baseResults/spv.meshTaskShader.task.out | 172 + Test/baseResults/test.conf | 9 + Test/spv.meshShaderBuiltins.mesh | 63 + Test/spv.meshShaderPerViewBuiltins.mesh | 42 + Test/spv.meshShaderPerViewUserDefined.mesh | 56 + Test/spv.meshShaderSharedMem.mesh | 39 + Test/spv.meshShaderTaskMem.mesh | 41 + Test/spv.meshShaderUserDefined.mesh | 59 + Test/spv.meshTaskShader.task | 49 + glslang/Include/BaseTypes.h | 16 + glslang/Include/ResourceLimits.h | 11 + glslang/Include/Types.h | 52 +- glslang/Include/intermediate.h | 3 + glslang/MachineIndependent/Initialize.cpp | 375 +- glslang/MachineIndependent/ParseHelper.cpp | 347 +- glslang/MachineIndependent/ParseHelper.h | 7 +- glslang/MachineIndependent/Scan.cpp | 16 + glslang/MachineIndependent/ShaderLang.cpp | 22 + glslang/MachineIndependent/Versions.cpp | 6 + glslang/MachineIndependent/Versions.h | 2 + glslang/MachineIndependent/glslang.y | 30 +- glslang/MachineIndependent/glslang_tab.cpp | 7791 +++++++++-------- glslang/MachineIndependent/glslang_tab.cpp.h | 553 +- glslang/MachineIndependent/intermOut.cpp | 14 + glslang/MachineIndependent/linkValidate.cpp | 51 +- .../MachineIndependent/localintermediate.h | 16 + glslang/Public/ShaderLang.h | 8 + gtests/Spv.FromFile.cpp | 7 + gtests/TestFixture.cpp | 6 + 41 files changed, 6976 insertions(+), 4237 deletions(-) create mode 100644 Test/baseResults/spv.meshShaderBuiltins.mesh.out create mode 100644 Test/baseResults/spv.meshShaderPerViewBuiltins.mesh.out create mode 100644 Test/baseResults/spv.meshShaderPerViewUserDefined.mesh.out create mode 100644 Test/baseResults/spv.meshShaderSharedMem.mesh.out create mode 100644 Test/baseResults/spv.meshShaderTaskMem.mesh.out create mode 100644 Test/baseResults/spv.meshShaderUserDefined.mesh.out create mode 100644 Test/baseResults/spv.meshTaskShader.task.out create mode 100644 Test/spv.meshShaderBuiltins.mesh create mode 100644 Test/spv.meshShaderPerViewBuiltins.mesh create mode 100644 Test/spv.meshShaderPerViewUserDefined.mesh create mode 100644 Test/spv.meshShaderSharedMem.mesh create mode 100644 Test/spv.meshShaderTaskMem.mesh create mode 100644 Test/spv.meshShaderUserDefined.mesh create mode 100644 Test/spv.meshTaskShader.task diff --git a/SPIRV/GLSL.ext.NV.h b/SPIRV/GLSL.ext.NV.h index 651ef0922..9c551d1cf 100644 --- a/SPIRV/GLSL.ext.NV.h +++ b/SPIRV/GLSL.ext.NV.h @@ -33,7 +33,7 @@ enum Op; enum Capability; static const int GLSLextNVVersion = 100; -static const int GLSLextNVRevision = 8; +static const int GLSLextNVRevision = 9; //SPV_NV_sample_mask_override_coverage const char* const E_SPV_NV_sample_mask_override_coverage = "SPV_NV_sample_mask_override_coverage"; @@ -63,4 +63,7 @@ const char* const E_SPV_NV_compute_shader_derivatives = "SPV_NV_compute_shader_d //SPV_NV_shader_image_footprint const char* const E_SPV_NV_shader_image_footprint = "SPV_NV_shader_image_footprint"; +//SPV_NV_mesh_shader +const char* const E_SPV_NV_mesh_shader = "SPV_NV_mesh_shader"; + #endif // #ifndef GLSLextNV_H \ No newline at end of file diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp index 842582f52..11d8e3150 100755 --- a/SPIRV/GlslangToSpv.cpp +++ b/SPIRV/GlslangToSpv.cpp @@ -194,6 +194,9 @@ protected: spv::Id createMiscOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId, std::vector& operands, glslang::TBasicType typeProxy); spv::Id createNoArgOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId); spv::Id getSymbolId(const glslang::TIntermSymbol* node); +#ifdef NV_EXTENSIONS + void addMeshNVDecoration(spv::Id id, int member, const glslang::TQualifier & qualifier); +#endif spv::Id createSpvConstant(const glslang::TIntermTyped&); spv::Id createSpvConstantFromConstUnionArray(const glslang::TType& type, const glslang::TConstUnionArray&, int& nextConst, bool specConstant); bool isTrivialLeaf(const glslang::TIntermTyped* node); @@ -272,6 +275,10 @@ spv::ExecutionModel TranslateExecutionModel(EShLanguage stage) case EShLangGeometry: return spv::ExecutionModelGeometry; case EShLangFragment: return spv::ExecutionModelFragment; case EShLangCompute: return spv::ExecutionModelGLCompute; +#ifdef NV_EXTENSIONS + case EShLangTaskNV: return spv::ExecutionModelTaskNV; + case EShLangMeshNV: return spv::ExecutionModelMeshNV; +#endif default: assert(0); return spv::ExecutionModelFragment; @@ -379,7 +386,15 @@ spv::Decoration TranslateLayoutDecoration(const glslang::TType& type, glslang::T } case glslang::EvqVaryingIn: case glslang::EvqVaryingOut: - assert(type.getQualifier().layoutPacking == glslang::ElpNone); + if (type.getQualifier().isTaskMemory()) { + switch (type.getQualifier().layoutPacking) { + case glslang::ElpShared: return spv::DecorationGLSLShared; + case glslang::ElpPacked: return spv::DecorationGLSLPacked; + default: break; + } + } else { + assert(type.getQualifier().layoutPacking == glslang::ElpNone); + } return spv::DecorationMax; default: assert(0); @@ -619,6 +634,11 @@ spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltI return spv::BuiltInSampleMask; case glslang::EbvLayer: +#ifdef NV_EXTENSIONS + if (glslangIntermediate->getStage() == EShLangMeshNV) { + return spv::BuiltInLayer; + } +#endif builder.addCapability(spv::CapabilityGeometry); if (glslangIntermediate->getStage() == EShLangVertex || glslangIntermediate->getStage() == EShLangTessControl || @@ -835,6 +855,22 @@ spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltI builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric); builder.addCapability(spv::CapabilityFragmentBarycentricNV); return spv::BuiltInBaryCoordNoPerspNV; + case glslang::EbvTaskCountNV: + return spv::BuiltInTaskCountNV; + case glslang::EbvPrimitiveCountNV: + return spv::BuiltInPrimitiveCountNV; + case glslang::EbvPrimitiveIndicesNV: + return spv::BuiltInPrimitiveIndicesNV; + case glslang::EbvClipDistancePerViewNV: + return spv::BuiltInClipDistancePerViewNV; + case glslang::EbvCullDistancePerViewNV: + return spv::BuiltInCullDistancePerViewNV; + case glslang::EbvLayerPerViewNV: + return spv::BuiltInLayerPerViewNV; + case glslang::EbvMeshViewCountNV: + return spv::BuiltInMeshViewCountNV; + case glslang::EbvMeshViewIndicesNV: + return spv::BuiltInMeshViewIndicesNV; #endif default: return spv::BuiltInMax; @@ -1110,6 +1146,14 @@ void InheritQualifiers(glslang::TQualifier& child, const glslang::TQualifier& pa child.readonly = true; if (parent.writeonly) child.writeonly = true; +#ifdef NV_EXTENSIONS + if (parent.perPrimitiveNV) + child.perPrimitiveNV = true; + if (parent.perViewNV) + child.perViewNV = true; + if (parent.perTaskNV) + child.perTaskNV = true; +#endif } bool HasNonLayoutQualifiers(const glslang::TType& type, const glslang::TQualifier& qualifier) @@ -1313,6 +1357,30 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion, const gl #endif break; +#ifdef NV_EXTENSIONS + case EShLangTaskNV: + case EShLangMeshNV: + builder.addCapability(spv::CapabilityMeshShadingNV); + builder.addExtension(spv::E_SPV_NV_mesh_shader); + builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0), + glslangIntermediate->getLocalSize(1), + glslangIntermediate->getLocalSize(2)); + if (glslangIntermediate->getStage() == EShLangMeshNV) { + builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices, glslangIntermediate->getVertices()); + builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputPrimitivesNV, glslangIntermediate->getPrimitives()); + + switch (glslangIntermediate->getOutputPrimitive()) { + case glslang::ElgPoints: mode = spv::ExecutionModeOutputPoints; break; + case glslang::ElgLines: mode = spv::ExecutionModeOutputLinesNV; break; + case glslang::ElgTriangles: mode = spv::ExecutionModeOutputTrianglesNV; break; + default: mode = spv::ExecutionModeMax; break; + } + if (mode != spv::ExecutionModeMax) + builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode); + } + break; +#endif + default: break; } @@ -2120,6 +2188,12 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt atomic = true; break; +#ifdef NV_EXTENSIONS + case glslang::EOpWritePackedPrimitiveIndices4x8NV: + noReturnValue = true; + break; +#endif + default: break; } @@ -2892,23 +2966,28 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty // bool TGlslangToSpvTraverser::filterMember(const glslang::TType& member) { +#ifdef NV_EXTENSIONS auto& extensions = glslangIntermediate->getRequestedExtensions(); - if (member.getFieldName() == "gl_ViewportMask" && - extensions.find("GL_NV_viewport_array2") == extensions.end()) - return true; if (member.getFieldName() == "gl_SecondaryViewportMaskNV" && extensions.find("GL_NV_stereo_view_rendering") == extensions.end()) return true; if (member.getFieldName() == "gl_SecondaryPositionNV" && extensions.find("GL_NV_stereo_view_rendering") == extensions.end()) return true; - if (member.getFieldName() == "gl_PositionPerViewNV" && - extensions.find("GL_NVX_multiview_per_view_attributes") == extensions.end()) - return true; - if (member.getFieldName() == "gl_ViewportMaskPerViewNV" && - extensions.find("GL_NVX_multiview_per_view_attributes") == extensions.end()) - return true; + + if (glslangIntermediate->getStage() != EShLangMeshNV) { + if (member.getFieldName() == "gl_ViewportMask" && + extensions.find("GL_NV_viewport_array2") == extensions.end()) + return true; + if (member.getFieldName() == "gl_PositionPerViewNV" && + extensions.find("GL_NVX_multiview_per_view_attributes") == extensions.end()) + return true; + if (member.getFieldName() == "gl_ViewportMaskPerViewNV" && + extensions.find("GL_NVX_multiview_per_view_attributes") == extensions.end()) + return true; + } +#endif return false; }; @@ -3001,6 +3080,9 @@ void TGlslangToSpvTraverser::decorateStructType(const glslang::TType& type, glslangIntermediate->getSource() == glslang::EShSourceHlsl) { builder.addMemberDecoration(spvType, member, TranslateInterpolationDecoration(memberQualifier)); builder.addMemberDecoration(spvType, member, TranslateAuxiliaryStorageDecoration(memberQualifier)); +#ifdef NV_EXTENSIONS + addMeshNVDecoration(spvType, member, memberQualifier); +#endif } } builder.addMemberDecoration(spvType, member, TranslateInvariantDecoration(memberQualifier)); @@ -3272,9 +3354,10 @@ glslang::TLayoutPacking TGlslangToSpvTraverser::getExplicitLayout(const glslang: if (type.getBasicType() != glslang::EbtBlock) return glslang::ElpNone; - // has to be a uniform or buffer block + // has to be a uniform or buffer block or task in/out blocks if (type.getQualifier().storage != glslang::EvqUniform && - type.getQualifier().storage != glslang::EvqBuffer) + type.getQualifier().storage != glslang::EvqBuffer && + !type.getQualifier().isTaskMemory()) return glslang::ElpNone; // return the layout to use @@ -3388,6 +3471,14 @@ void TGlslangToSpvTraverser::declareUseOfStructMember(const glslang::TTypeList& case glslang::EbvSecondaryViewportMaskNV: case glslang::EbvPositionPerViewNV: case glslang::EbvViewportMaskPerViewNV: + case glslang::EbvTaskCountNV: + case glslang::EbvPrimitiveCountNV: + case glslang::EbvPrimitiveIndicesNV: + case glslang::EbvClipDistancePerViewNV: + case glslang::EbvCullDistancePerViewNV: + case glslang::EbvLayerPerViewNV: + case glslang::EbvMeshViewCountNV: + case glslang::EbvMeshViewIndicesNV: #endif // Generate the associated capability. Delegate to TranslateBuiltInDecoration. // Alternately, we could just call this for any glslang built-in, since the @@ -6691,6 +6782,12 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv:: return 0; } break; + +#ifdef NV_EXTENSIONS + case glslang::EOpWritePackedPrimitiveIndices4x8NV: + builder.createNoResultOp(spv::OpWritePackedPrimitiveIndices4x8NV, operands); + return 0; +#endif default: return 0; } @@ -6888,6 +6985,9 @@ spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol builder.addDecoration(id, TranslatePrecisionDecoration(symbol->getType())); builder.addDecoration(id, TranslateInterpolationDecoration(symbol->getType().getQualifier())); builder.addDecoration(id, TranslateAuxiliaryStorageDecoration(symbol->getType().getQualifier())); +#ifdef NV_EXTENSIONS + addMeshNVDecoration(id, /*member*/ -1, symbol->getType().getQualifier()); +#endif if (symbol->getType().getQualifier().hasSpecConstantId()) builder.addDecoration(id, spv::DecorationSpecId, symbol->getType().getQualifier().layoutSpecConstantId); if (symbol->getQualifier().hasIndex()) @@ -6994,6 +7094,28 @@ spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol return id; } +#ifdef NV_EXTENSIONS +// add per-primitive, per-view. per-task decorations to a struct member (member >= 0) or an object +void TGlslangToSpvTraverser::addMeshNVDecoration(spv::Id id, int member, const glslang::TQualifier& qualifier) +{ + if (member >= 0) { + if (qualifier.perPrimitiveNV) + builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerPrimitiveNV); + if (qualifier.perViewNV) + builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerViewNV); + if (qualifier.perTaskNV) + builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerTaskNV); + } else { + if (qualifier.perPrimitiveNV) + builder.addDecoration(id, spv::DecorationPerPrimitiveNV); + if (qualifier.perViewNV) + builder.addDecoration(id, spv::DecorationPerViewNV); + if (qualifier.perTaskNV) + builder.addDecoration(id, spv::DecorationPerTaskNV); + } +} +#endif + // Make a full tree of instructions to build a SPIR-V specialization constant, // or regular constant if possible. // diff --git a/SPIRV/disassemble.cpp b/SPIRV/disassemble.cpp index 026699787..22c83ea9d 100644 --- a/SPIRV/disassemble.cpp +++ b/SPIRV/disassemble.cpp @@ -511,7 +511,8 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode, strcmp(spv::E_SPV_NV_geometry_shader_passthrough, name) == 0 || strcmp(spv::E_SPV_NV_viewport_array2, name) == 0 || strcmp(spv::E_SPV_NVX_multiview_per_view_attributes, name) == 0 || - strcmp(spv::E_SPV_NV_fragment_shader_barycentric, name) == 0) { + strcmp(spv::E_SPV_NV_fragment_shader_barycentric, name) == 0 || + strcmp(spv::E_SPV_NV_mesh_shader, name) == 0) { extInstSet = GLSLextNVInst; #endif } @@ -693,25 +694,44 @@ static const char* GLSLextNVGetDebugNames(const char* name, unsigned entrypoint) strcmp(name, spv::E_ARB_shader_viewport_layer_array) == 0 || strcmp(name, spv::E_SPV_NV_viewport_array2) == 0 || strcmp(spv::E_SPV_NVX_multiview_per_view_attributes, name) == 0 || - strcmp(spv::E_SPV_NV_fragment_shader_barycentric, name) == 0) { + strcmp(spv::E_SPV_NV_fragment_shader_barycentric, name) == 0 || + strcmp(name, spv::E_SPV_NV_mesh_shader) == 0) { switch (entrypoint) { - case DecorationOverrideCoverageNV: return "OverrideCoverageNV"; - case DecorationPassthroughNV: return "PassthroughNV"; - case CapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV"; - case DecorationViewportRelativeNV: return "ViewportRelativeNV"; + // NV builtins case BuiltInViewportMaskNV: return "ViewportMaskNV"; - case CapabilityShaderViewportMaskNV: return "ShaderViewportMaskNV"; - case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV"; case BuiltInSecondaryPositionNV: return "SecondaryPositionNV"; case BuiltInSecondaryViewportMaskNV: return "SecondaryViewportMaskNV"; - case CapabilityShaderStereoViewNV: return "ShaderStereoViewNV"; case BuiltInPositionPerViewNV: return "PositionPerViewNV"; case BuiltInViewportMaskPerViewNV: return "ViewportMaskPerViewNV"; - case CapabilityPerViewAttributesNV: return "PerViewAttributesNV"; - case CapabilityFragmentBarycentricNV: return "FragmentBarycentricNV"; - case DecorationPerVertexNV: return "PerVertexNV"; case BuiltInBaryCoordNV: return "BaryCoordNV"; case BuiltInBaryCoordNoPerspNV: return "BaryCoordNoPerspNV"; + case BuiltInTaskCountNV: return "TaskCountNV"; + case BuiltInPrimitiveCountNV: return "PrimitiveCountNV"; + case BuiltInPrimitiveIndicesNV: return "PrimitiveIndicesNV"; + case BuiltInClipDistancePerViewNV: return "ClipDistancePerViewNV"; + case BuiltInCullDistancePerViewNV: return "CullDistancePerViewNV"; + case BuiltInLayerPerViewNV: return "LayerPerViewNV"; + case BuiltInMeshViewCountNV: return "MeshViewCountNV"; + case BuiltInMeshViewIndicesNV: return "MeshViewIndicesNV"; + + // NV Capabilities + case CapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV"; + case CapabilityShaderViewportMaskNV: return "ShaderViewportMaskNV"; + case CapabilityShaderStereoViewNV: return "ShaderStereoViewNV"; + case CapabilityPerViewAttributesNV: return "PerViewAttributesNV"; + case CapabilityFragmentBarycentricNV: return "FragmentBarycentricNV"; + case CapabilityMeshShadingNV: return "MeshShadingNV"; + + // NV Decorations + case DecorationOverrideCoverageNV: return "OverrideCoverageNV"; + case DecorationPassthroughNV: return "PassthroughNV"; + case DecorationViewportRelativeNV: return "ViewportRelativeNV"; + case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV"; + case DecorationPerVertexNV: return "PerVertexNV"; + case DecorationPerPrimitiveNV: return "PerPrimitiveNV"; + case DecorationPerViewNV: return "PerViewNV"; + case DecorationPerTaskNV: return "PerTaskNV"; + default: return "Bad"; } } diff --git a/SPIRV/doc.cpp b/SPIRV/doc.cpp index 7cf3fc8de..dc46c9547 100644 --- a/SPIRV/doc.cpp +++ b/SPIRV/doc.cpp @@ -98,6 +98,10 @@ const char* ExecutionModelString(int model) case 4: return "Fragment"; case 5: return "GLCompute"; case 6: return "Kernel"; +#ifdef NV_EXTENSIONS + case ExecutionModelTaskNV: return "TaskNV"; + case ExecutionModelMeshNV: return "MeshNV"; +#endif default: return "Bad"; } @@ -168,6 +172,9 @@ const char* ExecutionModeString(int mode) case 4446: return "PostDepthCoverage"; #ifdef NV_EXTENSIONS + case ExecutionModeOutputLinesNV: return "OutputLinesNV"; + case ExecutionModeOutputPrimitivesNV: return "OutputPrimitivesNV"; + case ExecutionModeOutputTrianglesNV: return "OutputTrianglesNV"; case ExecutionModeDerivativeGroupQuadsNV: return "DerivativeGroupQuadsNV"; case ExecutionModeDerivativeGroupLinearNV: return "DerivativeGroupLinearNV"; #endif @@ -260,6 +267,9 @@ const char* DecorationString(int decoration) case DecorationPassthroughNV: return "PassthroughNV"; case DecorationViewportRelativeNV: return "ViewportRelativeNV"; case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV"; + case DecorationPerPrimitiveNV: return "PerPrimitiveNV"; + case DecorationPerViewNV: return "PerViewNV"; + case DecorationPerTaskNV: return "PerTaskNV"; case DecorationPerVertexNV: return "PerVertexNV"; #endif @@ -351,6 +361,18 @@ const char* BuiltInString(int builtIn) case 5264: return "FullyCoveredEXT"; + +#ifdef NV_EXTENSIONS + case BuiltInTaskCountNV: return "TaskCountNV"; + case BuiltInPrimitiveCountNV: return "PrimitiveCountNV"; + case BuiltInPrimitiveIndicesNV: return "PrimitiveIndicesNV"; + case BuiltInClipDistancePerViewNV: return "ClipDistancePerViewNV"; + case BuiltInCullDistancePerViewNV: return "CullDistancePerViewNV"; + case BuiltInLayerPerViewNV: return "LayerPerViewNV"; + case BuiltInMeshViewCountNV: return "MeshViewCountNV"; + case BuiltInMeshViewIndicesNV: return "MeshViewIndicesNV"; +#endif + default: return "Bad"; } } @@ -838,6 +860,7 @@ const char* CapabilityString(int info) case CapabilityComputeDerivativeGroupQuadsNV: return "ComputeDerivativeGroupQuadsNV"; case CapabilityComputeDerivativeGroupLinearNV: return "ComputeDerivativeGroupLinearNV"; case CapabilityFragmentBarycentricNV: return "FragmentBarycentricNV"; + case CapabilityMeshShadingNV: return "MeshShadingNV"; #endif case CapabilityFragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT"; @@ -1250,8 +1273,9 @@ const char* OpcodeString(int op) case OpMemberDecorateStringGOOGLE: return "OpMemberDecorateStringGOOGLE"; #ifdef NV_EXTENSIONS - case OpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV"; - case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV"; + case OpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV"; + case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV"; + case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV"; #endif default: @@ -2598,12 +2622,16 @@ void Parameterize() #ifdef NV_EXTENSIONS InstructionDesc[OpGroupNonUniformPartitionNV].operands.push(OperandId, "X"); + InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Sampled Image'"); InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coordinate'"); InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Granularity'"); InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coarse'"); InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandImageOperands, "", true); InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandVariableIds, "", true); + + InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Index Offset'"); + InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Packed Indices'"); #endif } diff --git a/StandAlone/ResourceLimits.cpp b/StandAlone/ResourceLimits.cpp index e22ec8015..0765ed1da 100644 --- a/StandAlone/ResourceLimits.cpp +++ b/StandAlone/ResourceLimits.cpp @@ -125,6 +125,18 @@ const TBuiltInResource DefaultTBuiltInResource = { /* .MaxCullDistances = */ 8, /* .MaxCombinedClipAndCullDistances = */ 8, /* .MaxSamples = */ 4, +#ifdef NV_EXTENSIONS + /* .maxMeshOutputVerticesNV = */ 256, + /* .maxMeshOutputPrimitivesNV = */ 512, + /* .maxMeshWorkGroupSizeX_NV = */ 32, + /* .maxMeshWorkGroupSizeY_NV = */ 1, + /* .maxMeshWorkGroupSizeZ_NV = */ 1, + /* .maxTaskWorkGroupSizeX_NV = */ 32, + /* .maxTaskWorkGroupSizeY_NV = */ 1, + /* .maxTaskWorkGroupSizeZ_NV = */ 1, + /* .maxMeshViewCountNV = */ 4, +#endif + /* .limits = */ { /* .nonInductiveForLoops = */ 1, /* .whileLoops = */ 1, @@ -224,7 +236,17 @@ std::string GetDefaultTBuiltInResourceString() << "MaxCullDistances " << DefaultTBuiltInResource.maxCullDistances << "\n" << "MaxCombinedClipAndCullDistances " << DefaultTBuiltInResource.maxCombinedClipAndCullDistances << "\n" << "MaxSamples " << DefaultTBuiltInResource.maxSamples << "\n" - +#ifdef NV_EXTENSIONS + << "MaxMeshOutputVerticesNV " << DefaultTBuiltInResource.maxMeshOutputVerticesNV << "\n" + << "MaxMeshOutputPrimitivesNV " << DefaultTBuiltInResource.maxMeshOutputPrimitivesNV << "\n" + << "MaxMeshWorkGroupSizeX_NV " << DefaultTBuiltInResource.maxMeshWorkGroupSizeX_NV << "\n" + << "MaxMeshWorkGroupSizeY_NV " << DefaultTBuiltInResource.maxMeshWorkGroupSizeY_NV << "\n" + << "MaxMeshWorkGroupSizeZ_NV " << DefaultTBuiltInResource.maxMeshWorkGroupSizeZ_NV << "\n" + << "MaxTaskWorkGroupSizeX_NV " << DefaultTBuiltInResource.maxTaskWorkGroupSizeX_NV << "\n" + << "MaxTaskWorkGroupSizeY_NV " << DefaultTBuiltInResource.maxTaskWorkGroupSizeY_NV << "\n" + << "MaxTaskWorkGroupSizeZ_NV " << DefaultTBuiltInResource.maxTaskWorkGroupSizeZ_NV << "\n" + << "MaxMeshViewCountNV " << DefaultTBuiltInResource.maxMeshViewCountNV << "\n" +#endif << "nonInductiveForLoops " << DefaultTBuiltInResource.limits.nonInductiveForLoops << "\n" << "whileLoops " << DefaultTBuiltInResource.limits.whileLoops << "\n" << "doWhileLoops " << DefaultTBuiltInResource.limits.doWhileLoops << "\n" @@ -431,6 +453,26 @@ void DecodeResourceLimits(TBuiltInResource* resources, char* config) resources->maxCombinedClipAndCullDistances = value; else if (tokenStr == "MaxSamples") resources->maxSamples = value; +#ifdef NV_EXTENSIONS + else if (tokenStr == "MaxMeshOutputVerticesNV") + resources->maxMeshOutputVerticesNV = value; + else if (tokenStr == "MaxMeshOutputPrimitivesNV") + resources->maxMeshOutputPrimitivesNV = value; + else if (tokenStr == "MaxMeshWorkGroupSizeX_NV") + resources->maxMeshWorkGroupSizeX_NV = value; + else if (tokenStr == "MaxMeshWorkGroupSizeY_NV") + resources->maxMeshWorkGroupSizeY_NV = value; + else if (tokenStr == "MaxMeshWorkGroupSizeZ_NV") + resources->maxMeshWorkGroupSizeZ_NV = value; + else if (tokenStr == "MaxTaskWorkGroupSizeX_NV") + resources->maxTaskWorkGroupSizeX_NV = value; + else if (tokenStr == "MaxTaskWorkGroupSizeY_NV") + resources->maxTaskWorkGroupSizeY_NV = value; + else if (tokenStr == "MaxTaskWorkGroupSizeZ_NV") + resources->maxTaskWorkGroupSizeZ_NV = value; + else if (tokenStr == "MaxMeshViewCountNV") + resources->maxMeshViewCountNV = value; +#endif else if (tokenStr == "nonInductiveForLoops") resources->limits.nonInductiveForLoops = (value != 0); else if (tokenStr == "whileLoops") diff --git a/StandAlone/StandAlone.cpp b/StandAlone/StandAlone.cpp index 38ba597d7..fc0a4b58c 100644 --- a/StandAlone/StandAlone.cpp +++ b/StandAlone/StandAlone.cpp @@ -244,6 +244,10 @@ const char* GetBinaryName(EShLanguage stage) case EShLangGeometry: name = "geom.spv"; break; case EShLangFragment: name = "frag.spv"; break; case EShLangCompute: name = "comp.spv"; break; +#ifdef NV_EXTENSIONS + case EShLangMeshNV: name = "mesh.spv"; break; + case EShLangTaskNV: name = "task.spv"; break; +#endif default: name = "unknown"; break; } } else @@ -1250,6 +1254,12 @@ EShLanguage FindLanguage(const std::string& name, bool parseStageName) return EShLangFragment; else if (stageName == "comp") return EShLangCompute; +#ifdef NV_EXTENSIONS + else if (stageName == "mesh") + return EShLangMeshNV; + else if (stageName == "task") + return EShLangTaskNV; +#endif usage(); return EShLangVertex; @@ -1319,6 +1329,10 @@ void usage() " .geom for a geometry shader\n" " .frag for a fragment shader\n" " .comp for a compute shader\n" +#ifdef NV_EXTENSIONS + " .mesh for a mesh shader\n" + " .task for a task shader\n" +#endif " .glsl for .vert.glsl, .tesc.glsl, ..., .comp.glsl compound suffixes\n" " .hlsl for .vert.hlsl, .tesc.hlsl, ..., .comp.hlsl compound suffixes\n" "\n" diff --git a/Test/baseResults/spv.meshShaderBuiltins.mesh.out b/Test/baseResults/spv.meshShaderBuiltins.mesh.out new file mode 100644 index 000000000..ef4ff4d8e --- /dev/null +++ b/Test/baseResults/spv.meshShaderBuiltins.mesh.out @@ -0,0 +1,259 @@ +spv.meshShaderBuiltins.mesh +// Module Version 10000 +// Generated by (magic number): 80007 +// Id's are bound by 147 + + Capability ClipDistance + Capability CullDistance + Capability MultiViewport + Capability DrawParameters + Capability ShaderViewportMaskNV + Capability MeshShadingNV + Extension "SPV_KHR_shader_draw_parameters" + Extension "SPV_NV_mesh_shader" + Extension "SPV_NV_viewport_array2" + 1: ExtInstImport "GLSL.std.450" + MemoryModel Logical GLSL450 + EntryPoint MeshNV 4 "main" 11 17 34 89 129 140 144 + ExecutionMode 4 LocalSize 32 1 1 + ExecutionMode 4 OutputVertices 81 + ExecutionMode 4 OutputPrimitivesNV 32 + ExecutionMode 4 OutputTrianglesNV + Source GLSL 460 + SourceExtension "GL_NV_mesh_shader" + Name 4 "main" + Name 8 "iid" + Name 11 "gl_LocalInvocationID" + Name 16 "gid" + Name 17 "gl_WorkGroupID" + Name 30 "gl_MeshPerVertexNV" + MemberName 30(gl_MeshPerVertexNV) 0 "gl_Position" + MemberName 30(gl_MeshPerVertexNV) 1 "gl_PointSize" + MemberName 30(gl_MeshPerVertexNV) 2 "gl_ClipDistance" + MemberName 30(gl_MeshPerVertexNV) 3 "gl_CullDistance" + MemberName 30(gl_MeshPerVertexNV) 4 "gl_PositionPerViewNV" + MemberName 30(gl_MeshPerVertexNV) 5 "gl_ClipDistancePerViewNV" + MemberName 30(gl_MeshPerVertexNV) 6 "gl_CullDistancePerViewNV" + Name 34 "gl_MeshVerticesNV" + Name 85 "gl_MeshPerPrimitiveNV" + MemberName 85(gl_MeshPerPrimitiveNV) 0 "gl_PrimitiveID" + MemberName 85(gl_MeshPerPrimitiveNV) 1 "gl_Layer" + MemberName 85(gl_MeshPerPrimitiveNV) 2 "gl_ViewportIndex" + MemberName 85(gl_MeshPerPrimitiveNV) 3 "gl_ViewportMask" + MemberName 85(gl_MeshPerPrimitiveNV) 4 "gl_LayerPerViewNV" + MemberName 85(gl_MeshPerPrimitiveNV) 5 "gl_ViewportMaskPerViewNV" + Name 89 "gl_MeshPrimitivesNV" + Name 129 "gl_PrimitiveIndicesNV" + Name 140 "gl_DrawID" + Name 144 "gl_PrimitiveCountNV" + Decorate 11(gl_LocalInvocationID) BuiltIn LocalInvocationId + Decorate 17(gl_WorkGroupID) BuiltIn WorkgroupId + MemberDecorate 30(gl_MeshPerVertexNV) 0 BuiltIn Position + MemberDecorate 30(gl_MeshPerVertexNV) 1 BuiltIn PointSize + MemberDecorate 30(gl_MeshPerVertexNV) 2 BuiltIn ClipDistance + MemberDecorate 30(gl_MeshPerVertexNV) 3 BuiltIn CullDistance + MemberDecorate 30(gl_MeshPerVertexNV) 4 PerViewNV + MemberDecorate 30(gl_MeshPerVertexNV) 4 BuiltIn PositionPerViewNV + MemberDecorate 30(gl_MeshPerVertexNV) 5 PerViewNV + MemberDecorate 30(gl_MeshPerVertexNV) 5 BuiltIn ClipDistancePerViewNV + MemberDecorate 30(gl_MeshPerVertexNV) 6 PerViewNV + MemberDecorate 30(gl_MeshPerVertexNV) 6 BuiltIn CullDistancePerViewNV + Decorate 30(gl_MeshPerVertexNV) Block + MemberDecorate 85(gl_MeshPerPrimitiveNV) 0 PerPrimitiveNV + MemberDecorate 85(gl_MeshPerPrimitiveNV) 0 BuiltIn PrimitiveId + MemberDecorate 85(gl_MeshPerPrimitiveNV) 1 PerPrimitiveNV + MemberDecorate 85(gl_MeshPerPrimitiveNV) 1 BuiltIn Layer + MemberDecorate 85(gl_MeshPerPrimitiveNV) 2 PerPrimitiveNV + MemberDecorate 85(gl_MeshPerPrimitiveNV) 2 BuiltIn ViewportIndex + MemberDecorate 85(gl_MeshPerPrimitiveNV) 3 PerPrimitiveNV + MemberDecorate 85(gl_MeshPerPrimitiveNV) 3 BuiltIn ViewportMaskNV + MemberDecorate 85(gl_MeshPerPrimitiveNV) 4 PerPrimitiveNV + MemberDecorate 85(gl_MeshPerPrimitiveNV) 4 PerViewNV + MemberDecorate 85(gl_MeshPerPrimitiveNV) 4 BuiltIn LayerPerViewNV + MemberDecorate 85(gl_MeshPerPrimitiveNV) 5 PerPrimitiveNV + MemberDecorate 85(gl_MeshPerPrimitiveNV) 5 PerViewNV + MemberDecorate 85(gl_MeshPerPrimitiveNV) 5 BuiltIn ViewportMaskPerViewNV + Decorate 85(gl_MeshPerPrimitiveNV) Block + Decorate 129(gl_PrimitiveIndicesNV) BuiltIn PrimitiveIndicesNV + Decorate 140(gl_DrawID) BuiltIn DrawIndex + Decorate 144(gl_PrimitiveCountNV) BuiltIn PrimitiveCountNV + Decorate 146 BuiltIn WorkgroupSize + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeInt 32 0 + 7: TypePointer Function 6(int) + 9: TypeVector 6(int) 3 + 10: TypePointer Input 9(ivec3) +11(gl_LocalInvocationID): 10(ptr) Variable Input + 12: 6(int) Constant 0 + 13: TypePointer Input 6(int) +17(gl_WorkGroupID): 10(ptr) Variable Input + 20: TypeFloat 32 + 21: TypeVector 20(float) 4 + 22: 6(int) Constant 4 + 23: TypeArray 20(float) 22 + 24: 6(int) Constant 3 + 25: TypeArray 20(float) 24 + 26: TypeArray 21(fvec4) 22 + 27: 6(int) Constant 8 + 28: TypeArray 20(float) 27 + 29: TypeArray 28 22 +30(gl_MeshPerVertexNV): TypeStruct 21(fvec4) 20(float) 23 25 26 29 29 + 31: 6(int) Constant 81 + 32: TypeArray 30(gl_MeshPerVertexNV) 31 + 33: TypePointer Output 32 +34(gl_MeshVerticesNV): 33(ptr) Variable Output + 36: TypeInt 32 1 + 37: 36(int) Constant 0 + 38: 20(float) Constant 1065353216 + 39: 21(fvec4) ConstantComposite 38 38 38 38 + 40: TypePointer Output 21(fvec4) + 43: 36(int) Constant 1 + 44: 20(float) Constant 1073741824 + 45: TypePointer Output 20(float) + 48: 36(int) Constant 2 + 49: 36(int) Constant 3 + 50: 20(float) Constant 1077936128 + 53: 20(float) Constant 1082130432 + 55: 6(int) Constant 1 + 56: 6(int) Constant 264 + 57: 6(int) Constant 2 + 82: TypeArray 36(int) 55 + 83: TypeArray 36(int) 22 + 84: TypeArray 82 22 +85(gl_MeshPerPrimitiveNV): TypeStruct 36(int) 36(int) 36(int) 82 83 84 + 86: 6(int) Constant 32 + 87: TypeArray 85(gl_MeshPerPrimitiveNV) 86 + 88: TypePointer Output 87 +89(gl_MeshPrimitivesNV): 88(ptr) Variable Output + 91: 36(int) Constant 6 + 92: TypePointer Output 36(int) + 95: 36(int) Constant 7 + 98: 36(int) Constant 8 + 101: 36(int) Constant 9 + 127: TypeArray 6(int) 31 + 128: TypePointer Output 127 +129(gl_PrimitiveIndicesNV): 128(ptr) Variable Output + 130: 6(int) Constant 257 + 131: TypePointer Output 6(int) + 139: TypePointer Input 36(int) + 140(gl_DrawID): 139(ptr) Variable Input + 143: 6(int) Constant 16909060 +144(gl_PrimitiveCountNV): 131(ptr) Variable Output + 145: 6(int) Constant 96 + 146: 9(ivec3) ConstantComposite 86 55 55 + 4(main): 2 Function None 3 + 5: Label + 8(iid): 7(ptr) Variable Function + 16(gid): 7(ptr) Variable Function + 14: 13(ptr) AccessChain 11(gl_LocalInvocationID) 12 + 15: 6(int) Load 14 + Store 8(iid) 15 + 18: 13(ptr) AccessChain 17(gl_WorkGroupID) 12 + 19: 6(int) Load 18 + Store 16(gid) 19 + 35: 6(int) Load 8(iid) + 41: 40(ptr) AccessChain 34(gl_MeshVerticesNV) 35 37 + Store 41 39 + 42: 6(int) Load 8(iid) + 46: 45(ptr) AccessChain 34(gl_MeshVerticesNV) 42 43 + Store 46 44 + 47: 6(int) Load 8(iid) + 51: 45(ptr) AccessChain 34(gl_MeshVerticesNV) 47 48 49 + Store 51 50 + 52: 6(int) Load 8(iid) + 54: 45(ptr) AccessChain 34(gl_MeshVerticesNV) 52 49 48 + Store 54 53 + MemoryBarrier 55 56 + ControlBarrier 57 57 56 + 58: 6(int) Load 8(iid) + 59: 6(int) IAdd 58 55 + 60: 6(int) Load 8(iid) + 61: 40(ptr) AccessChain 34(gl_MeshVerticesNV) 60 37 + 62: 21(fvec4) Load 61 + 63: 40(ptr) AccessChain 34(gl_MeshVerticesNV) 59 37 + Store 63 62 + 64: 6(int) Load 8(iid) + 65: 6(int) IAdd 64 55 + 66: 6(int) Load 8(iid) + 67: 45(ptr) AccessChain 34(gl_MeshVerticesNV) 66 43 + 68: 20(float) Load 67 + 69: 45(ptr) AccessChain 34(gl_MeshVerticesNV) 65 43 + Store 69 68 + 70: 6(int) Load 8(iid) + 71: 6(int) IAdd 70 55 + 72: 6(int) Load 8(iid) + 73: 45(ptr) AccessChain 34(gl_MeshVerticesNV) 72 48 49 + 74: 20(float) Load 73 + 75: 45(ptr) AccessChain 34(gl_MeshVerticesNV) 71 48 49 + Store 75 74 + 76: 6(int) Load 8(iid) + 77: 6(int) IAdd 76 55 + 78: 6(int) Load 8(iid) + 79: 45(ptr) AccessChain 34(gl_MeshVerticesNV) 78 49 48 + 80: 20(float) Load 79 + 81: 45(ptr) AccessChain 34(gl_MeshVerticesNV) 77 49 48 + Store 81 80 + MemoryBarrier 55 56 + ControlBarrier 57 57 56 + 90: 6(int) Load 8(iid) + 93: 92(ptr) AccessChain 89(gl_MeshPrimitivesNV) 90 37 + Store 93 91 + 94: 6(int) Load 8(iid) + 96: 92(ptr) AccessChain 89(gl_MeshPrimitivesNV) 94 43 + Store 96 95 + 97: 6(int) Load 8(iid) + 99: 92(ptr) AccessChain 89(gl_MeshPrimitivesNV) 97 48 + Store 99 98 + 100: 6(int) Load 8(iid) + 102: 92(ptr) AccessChain 89(gl_MeshPrimitivesNV) 100 49 37 + Store 102 101 + MemoryBarrier 55 56 + ControlBarrier 57 57 56 + 103: 6(int) Load 8(iid) + 104: 6(int) IAdd 103 55 + 105: 6(int) Load 8(iid) + 106: 92(ptr) AccessChain 89(gl_MeshPrimitivesNV) 105 37 + 107: 36(int) Load 106 + 108: 92(ptr) AccessChain 89(gl_MeshPrimitivesNV) 104 37 + Store 108 107 + 109: 6(int) Load 8(iid) + 110: 6(int) IAdd 109 55 + 111: 6(int) Load 8(iid) + 112: 92(ptr) AccessChain 89(gl_MeshPrimitivesNV) 111 43 + 113: 36(int) Load 112 + 114: 92(ptr) AccessChain 89(gl_MeshPrimitivesNV) 110 43 + Store 114 113 + 115: 6(int) Load 8(iid) + 116: 6(int) IAdd 115 55 + 117: 6(int) Load 8(iid) + 118: 92(ptr) AccessChain 89(gl_MeshPrimitivesNV) 117 48 + 119: 36(int) Load 118 + 120: 92(ptr) AccessChain 89(gl_MeshPrimitivesNV) 116 48 + Store 120 119 + 121: 6(int) Load 8(iid) + 122: 6(int) IAdd 121 55 + 123: 6(int) Load 8(iid) + 124: 92(ptr) AccessChain 89(gl_MeshPrimitivesNV) 123 49 37 + 125: 36(int) Load 124 + 126: 92(ptr) AccessChain 89(gl_MeshPrimitivesNV) 122 49 37 + Store 126 125 + MemoryBarrier 55 56 + ControlBarrier 57 57 56 + 132: 131(ptr) AccessChain 129(gl_PrimitiveIndicesNV) 37 + Store 132 130 + 133: 6(int) Load 16(gid) + 134: 6(int) Load 16(gid) + 135: 6(int) ISub 134 55 + 136: 131(ptr) AccessChain 129(gl_PrimitiveIndicesNV) 135 + 137: 6(int) Load 136 + 138: 131(ptr) AccessChain 129(gl_PrimitiveIndicesNV) 133 + Store 138 137 + 141: 36(int) Load 140(gl_DrawID) + 142: 6(int) Bitcast 141 + 143: 142 WritePackedPrimitiveIndices4x8NV + Store 144(gl_PrimitiveCountNV) 145 + MemoryBarrier 55 56 + ControlBarrier 57 57 56 + Return + FunctionEnd diff --git a/Test/baseResults/spv.meshShaderPerViewBuiltins.mesh.out b/Test/baseResults/spv.meshShaderPerViewBuiltins.mesh.out new file mode 100644 index 000000000..c79a5c32f --- /dev/null +++ b/Test/baseResults/spv.meshShaderPerViewBuiltins.mesh.out @@ -0,0 +1,212 @@ +spv.meshShaderPerViewBuiltins.mesh +// Module Version 10000 +// Generated by (magic number): 80007 +// Id's are bound by 124 + + Capability MultiViewport + Capability PerViewAttributesNV + Capability MeshShadingNV + Extension "SPV_NVX_multiview_per_view_attributes" + Extension "SPV_NV_mesh_shader" + 1: ExtInstImport "GLSL.std.450" + MemoryModel Logical GLSL450 + EntryPoint MeshNV 4 "main" 11 20 21 38 70 + ExecutionMode 4 LocalSize 32 1 1 + ExecutionMode 4 OutputVertices 81 + ExecutionMode 4 OutputPrimitivesNV 32 + ExecutionMode 4 OutputTrianglesNV + Source GLSL 450 + SourceExtension "GL_NV_mesh_shader" + Name 4 "main" + Name 8 "iid" + Name 11 "gl_LocalInvocationID" + Name 16 "viewID" + Name 20 "gl_MeshViewIndicesNV" + Name 21 "gl_MeshViewCountNV" + Name 34 "gl_MeshPerVertexNV" + MemberName 34(gl_MeshPerVertexNV) 0 "gl_Position" + MemberName 34(gl_MeshPerVertexNV) 1 "gl_PointSize" + MemberName 34(gl_MeshPerVertexNV) 2 "gl_ClipDistance" + MemberName 34(gl_MeshPerVertexNV) 3 "gl_CullDistance" + MemberName 34(gl_MeshPerVertexNV) 4 "gl_PositionPerViewNV" + MemberName 34(gl_MeshPerVertexNV) 5 "gl_ClipDistancePerViewNV" + MemberName 34(gl_MeshPerVertexNV) 6 "gl_CullDistancePerViewNV" + Name 38 "gl_MeshVerticesNV" + Name 66 "gl_MeshPerPrimitiveNV" + MemberName 66(gl_MeshPerPrimitiveNV) 0 "gl_PrimitiveID" + MemberName 66(gl_MeshPerPrimitiveNV) 1 "gl_Layer" + MemberName 66(gl_MeshPerPrimitiveNV) 2 "gl_ViewportIndex" + MemberName 66(gl_MeshPerPrimitiveNV) 3 "gl_ViewportMask" + MemberName 66(gl_MeshPerPrimitiveNV) 4 "gl_LayerPerViewNV" + MemberName 66(gl_MeshPerPrimitiveNV) 5 "gl_ViewportMaskPerViewNV" + Name 70 "gl_MeshPrimitivesNV" + Decorate 11(gl_LocalInvocationID) BuiltIn LocalInvocationId + Decorate 20(gl_MeshViewIndicesNV) BuiltIn MeshViewIndicesNV + Decorate 21(gl_MeshViewCountNV) BuiltIn MeshViewCountNV + MemberDecorate 34(gl_MeshPerVertexNV) 0 BuiltIn Position + MemberDecorate 34(gl_MeshPerVertexNV) 1 BuiltIn PointSize + MemberDecorate 34(gl_MeshPerVertexNV) 2 BuiltIn ClipDistance + MemberDecorate 34(gl_MeshPerVertexNV) 3 BuiltIn CullDistance + MemberDecorate 34(gl_MeshPerVertexNV) 4 PerViewNV + MemberDecorate 34(gl_MeshPerVertexNV) 4 BuiltIn PositionPerViewNV + MemberDecorate 34(gl_MeshPerVertexNV) 5 PerViewNV + MemberDecorate 34(gl_MeshPerVertexNV) 5 BuiltIn ClipDistancePerViewNV + MemberDecorate 34(gl_MeshPerVertexNV) 6 PerViewNV + MemberDecorate 34(gl_MeshPerVertexNV) 6 BuiltIn CullDistancePerViewNV + Decorate 34(gl_MeshPerVertexNV) Block + MemberDecorate 66(gl_MeshPerPrimitiveNV) 0 PerPrimitiveNV + MemberDecorate 66(gl_MeshPerPrimitiveNV) 0 BuiltIn PrimitiveId + MemberDecorate 66(gl_MeshPerPrimitiveNV) 1 PerPrimitiveNV + MemberDecorate 66(gl_MeshPerPrimitiveNV) 1 BuiltIn Layer + MemberDecorate 66(gl_MeshPerPrimitiveNV) 2 PerPrimitiveNV + MemberDecorate 66(gl_MeshPerPrimitiveNV) 2 BuiltIn ViewportIndex + MemberDecorate 66(gl_MeshPerPrimitiveNV) 3 PerPrimitiveNV + MemberDecorate 66(gl_MeshPerPrimitiveNV) 3 BuiltIn ViewportMaskNV + MemberDecorate 66(gl_MeshPerPrimitiveNV) 4 PerPrimitiveNV + MemberDecorate 66(gl_MeshPerPrimitiveNV) 4 PerViewNV + MemberDecorate 66(gl_MeshPerPrimitiveNV) 4 BuiltIn LayerPerViewNV + MemberDecorate 66(gl_MeshPerPrimitiveNV) 5 PerPrimitiveNV + MemberDecorate 66(gl_MeshPerPrimitiveNV) 5 PerViewNV + MemberDecorate 66(gl_MeshPerPrimitiveNV) 5 BuiltIn ViewportMaskPerViewNV + Decorate 66(gl_MeshPerPrimitiveNV) Block + Decorate 123 BuiltIn WorkgroupSize + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeInt 32 0 + 7: TypePointer Function 6(int) + 9: TypeVector 6(int) 3 + 10: TypePointer Input 9(ivec3) +11(gl_LocalInvocationID): 10(ptr) Variable Input + 12: 6(int) Constant 0 + 13: TypePointer Input 6(int) + 17: 6(int) Constant 4 + 18: TypeArray 6(int) 17 + 19: TypePointer Input 18 +20(gl_MeshViewIndicesNV): 19(ptr) Variable Input +21(gl_MeshViewCountNV): 13(ptr) Variable Input + 26: TypeFloat 32 + 27: TypeVector 26(float) 4 + 28: 6(int) Constant 1 + 29: TypeArray 26(float) 28 + 30: TypeArray 27(fvec4) 17 + 31: 6(int) Constant 8 + 32: TypeArray 26(float) 31 + 33: TypeArray 32 17 +34(gl_MeshPerVertexNV): TypeStruct 27(fvec4) 26(float) 29 29 30 33 33 + 35: 6(int) Constant 81 + 36: TypeArray 34(gl_MeshPerVertexNV) 35 + 37: TypePointer Output 36 +38(gl_MeshVerticesNV): 37(ptr) Variable Output + 40: TypeInt 32 1 + 41: 40(int) Constant 4 + 43: 26(float) Constant 1065353216 + 44: 26(float) Constant 1073741824 + 45: 26(float) Constant 1077936128 + 46: 26(float) Constant 1082130432 + 47: 27(fvec4) ConstantComposite 43 44 45 46 + 48: TypePointer Output 27(fvec4) + 51: 40(int) Constant 5 + 53: 40(int) Constant 2 + 54: 26(float) Constant 1084227584 + 55: TypePointer Output 26(float) + 58: 40(int) Constant 6 + 60: 40(int) Constant 3 + 61: 26(float) Constant 1086324736 + 63: TypeArray 40(int) 28 + 64: TypeArray 40(int) 17 + 65: TypeArray 63 17 +66(gl_MeshPerPrimitiveNV): TypeStruct 40(int) 40(int) 40(int) 63 64 65 + 67: 6(int) Constant 32 + 68: TypeArray 66(gl_MeshPerPrimitiveNV) 67 + 69: TypePointer Output 68 +70(gl_MeshPrimitivesNV): 69(ptr) Variable Output + 73: 40(int) Constant 7 + 74: TypePointer Output 40(int) + 78: 40(int) Constant 0 + 79: 40(int) Constant 8 + 81: 6(int) Constant 264 + 82: 6(int) Constant 2 + 123: 9(ivec3) ConstantComposite 67 28 28 + 4(main): 2 Function None 3 + 5: Label + 8(iid): 7(ptr) Variable Function + 16(viewID): 7(ptr) Variable Function + 14: 13(ptr) AccessChain 11(gl_LocalInvocationID) 12 + 15: 6(int) Load 14 + Store 8(iid) 15 + 22: 6(int) Load 21(gl_MeshViewCountNV) + 23: 6(int) UMod 22 17 + 24: 13(ptr) AccessChain 20(gl_MeshViewIndicesNV) 23 + 25: 6(int) Load 24 + Store 16(viewID) 25 + 39: 6(int) Load 8(iid) + 42: 6(int) Load 16(viewID) + 49: 48(ptr) AccessChain 38(gl_MeshVerticesNV) 39 41 42 + Store 49 47 + 50: 6(int) Load 8(iid) + 52: 6(int) Load 16(viewID) + 56: 55(ptr) AccessChain 38(gl_MeshVerticesNV) 50 51 52 53 + Store 56 54 + 57: 6(int) Load 8(iid) + 59: 6(int) Load 16(viewID) + 62: 55(ptr) AccessChain 38(gl_MeshVerticesNV) 57 58 59 60 + Store 62 61 + 71: 6(int) Load 8(iid) + 72: 6(int) Load 16(viewID) + 75: 74(ptr) AccessChain 70(gl_MeshPrimitivesNV) 71 41 72 + Store 75 73 + 76: 6(int) Load 8(iid) + 77: 6(int) Load 16(viewID) + 80: 74(ptr) AccessChain 70(gl_MeshPrimitivesNV) 76 51 77 78 + Store 80 79 + MemoryBarrier 28 81 + ControlBarrier 82 82 81 + 83: 6(int) Load 8(iid) + 84: 6(int) IAdd 83 28 + 85: 6(int) Load 16(viewID) + 86: 6(int) Load 8(iid) + 87: 6(int) Load 16(viewID) + 88: 48(ptr) AccessChain 38(gl_MeshVerticesNV) 86 41 87 + 89: 27(fvec4) Load 88 + 90: 48(ptr) AccessChain 38(gl_MeshVerticesNV) 84 41 85 + Store 90 89 + 91: 6(int) Load 8(iid) + 92: 6(int) IAdd 91 28 + 93: 6(int) Load 16(viewID) + 94: 6(int) Load 8(iid) + 95: 6(int) Load 16(viewID) + 96: 55(ptr) AccessChain 38(gl_MeshVerticesNV) 94 51 95 53 + 97: 26(float) Load 96 + 98: 55(ptr) AccessChain 38(gl_MeshVerticesNV) 92 51 93 53 + Store 98 97 + 99: 6(int) Load 8(iid) + 100: 6(int) IAdd 99 28 + 101: 6(int) Load 16(viewID) + 102: 6(int) Load 8(iid) + 103: 6(int) Load 16(viewID) + 104: 55(ptr) AccessChain 38(gl_MeshVerticesNV) 102 58 103 60 + 105: 26(float) Load 104 + 106: 55(ptr) AccessChain 38(gl_MeshVerticesNV) 100 58 101 60 + Store 106 105 + 107: 6(int) Load 8(iid) + 108: 6(int) IAdd 107 28 + 109: 6(int) Load 16(viewID) + 110: 6(int) Load 8(iid) + 111: 6(int) Load 16(viewID) + 112: 74(ptr) AccessChain 70(gl_MeshPrimitivesNV) 110 41 111 + 113: 40(int) Load 112 + 114: 74(ptr) AccessChain 70(gl_MeshPrimitivesNV) 108 41 109 + Store 114 113 + 115: 6(int) Load 8(iid) + 116: 6(int) IAdd 115 28 + 117: 6(int) Load 16(viewID) + 118: 6(int) Load 8(iid) + 119: 6(int) Load 16(viewID) + 120: 74(ptr) AccessChain 70(gl_MeshPrimitivesNV) 118 51 119 78 + 121: 40(int) Load 120 + 122: 74(ptr) AccessChain 70(gl_MeshPrimitivesNV) 116 51 117 78 + Store 122 121 + MemoryBarrier 28 81 + ControlBarrier 82 82 81 + Return + FunctionEnd diff --git a/Test/baseResults/spv.meshShaderPerViewUserDefined.mesh.out b/Test/baseResults/spv.meshShaderPerViewUserDefined.mesh.out new file mode 100644 index 000000000..7e7a37db9 --- /dev/null +++ b/Test/baseResults/spv.meshShaderPerViewUserDefined.mesh.out @@ -0,0 +1,156 @@ +spv.meshShaderPerViewUserDefined.mesh +// Module Version 10000 +// Generated by (magic number): 80007 +// Id's are bound by 90 + + Capability MeshShadingNV + Extension "SPV_NV_mesh_shader" + 1: ExtInstImport "GLSL.std.450" + MemoryModel Logical GLSL450 + EntryPoint MeshNV 4 "main" 11 20 21 35 67 + ExecutionMode 4 LocalSize 32 1 1 + ExecutionMode 4 OutputVertices 81 + ExecutionMode 4 OutputPrimitivesNV 32 + ExecutionMode 4 OutputTrianglesNV + Source GLSL 450 + SourceExtension "GL_NV_mesh_shader" + Name 4 "main" + Name 8 "iid" + Name 11 "gl_LocalInvocationID" + Name 16 "viewID" + Name 20 "gl_MeshViewIndicesNV" + Name 21 "gl_MeshViewCountNV" + Name 31 "block" + MemberName 31(block) 0 "color1" + MemberName 31(block) 1 "color2" + MemberName 31(block) 2 "color3" + MemberName 31(block) 3 "color4" + Name 35 "b" + Name 64 "perviewBlock" + MemberName 64(perviewBlock) 0 "color5" + MemberName 64(perviewBlock) 1 "color6" + MemberName 64(perviewBlock) 2 "color7" + MemberName 64(perviewBlock) 3 "color8" + Name 67 "b2" + Decorate 11(gl_LocalInvocationID) BuiltIn LocalInvocationId + Decorate 20(gl_MeshViewIndicesNV) BuiltIn MeshViewIndicesNV + Decorate 21(gl_MeshViewCountNV) BuiltIn MeshViewCountNV + MemberDecorate 31(block) 0 PerPrimitiveNV + MemberDecorate 31(block) 0 PerViewNV + MemberDecorate 31(block) 1 PerPrimitiveNV + MemberDecorate 31(block) 2 PerViewNV + Decorate 31(block) Block + Decorate 35(b) Location 0 + MemberDecorate 64(perviewBlock) 0 PerPrimitiveNV + MemberDecorate 64(perviewBlock) 0 PerViewNV + MemberDecorate 64(perviewBlock) 1 PerPrimitiveNV + MemberDecorate 64(perviewBlock) 1 PerViewNV + MemberDecorate 64(perviewBlock) 2 PerViewNV + MemberDecorate 64(perviewBlock) 3 PerViewNV + Decorate 64(perviewBlock) Block + Decorate 67(b2) Location 10 + Decorate 89 BuiltIn WorkgroupSize + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeInt 32 0 + 7: TypePointer Function 6(int) + 9: TypeVector 6(int) 3 + 10: TypePointer Input 9(ivec3) +11(gl_LocalInvocationID): 10(ptr) Variable Input + 12: 6(int) Constant 0 + 13: TypePointer Input 6(int) + 17: 6(int) Constant 4 + 18: TypeArray 6(int) 17 + 19: TypePointer Input 18 +20(gl_MeshViewIndicesNV): 19(ptr) Variable Input +21(gl_MeshViewCountNV): 13(ptr) Variable Input + 26: TypeFloat 32 + 27: TypeVector 26(float) 4 + 28: 6(int) Constant 3 + 29: TypeArray 27(fvec4) 28 + 30: TypeArray 29 17 + 31(block): TypeStruct 30 29 30 27(fvec4) + 32: 6(int) Constant 81 + 33: TypeArray 31(block) 32 + 34: TypePointer Output 33 + 35(b): 34(ptr) Variable Output + 37: TypeInt 32 1 + 38: 37(int) Constant 0 + 40: 37(int) Constant 2 + 41: 26(float) Constant 1065353216 + 42: 27(fvec4) ConstantComposite 41 41 41 41 + 43: TypePointer Output 27(fvec4) + 46: 37(int) Constant 1 + 47: 26(float) Constant 1073741824 + 48: 27(fvec4) ConstantComposite 47 47 47 47 + 52: 26(float) Constant 1077936128 + 53: 27(fvec4) ConstantComposite 52 52 52 52 + 56: 37(int) Constant 3 + 57: 26(float) Constant 1082130432 + 58: 27(fvec4) ConstantComposite 57 57 57 57 + 60: 6(int) Constant 1 + 61: 6(int) Constant 264 + 62: 6(int) Constant 2 + 63: TypeArray 27(fvec4) 17 +64(perviewBlock): TypeStruct 63 30 30 63 + 65: TypeArray 64(perviewBlock) 32 + 66: TypePointer Output 65 + 67(b2): 66(ptr) Variable Output + 70: 26(float) Constant 1084227584 + 71: 27(fvec4) ConstantComposite 70 70 70 70 + 75: 26(float) Constant 1086324736 + 76: 27(fvec4) ConstantComposite 75 75 75 75 + 80: 26(float) Constant 1088421888 + 81: 27(fvec4) ConstantComposite 80 80 80 80 + 85: 26(float) Constant 1090519040 + 86: 27(fvec4) ConstantComposite 85 85 85 85 + 88: 6(int) Constant 32 + 89: 9(ivec3) ConstantComposite 88 60 60 + 4(main): 2 Function None 3 + 5: Label + 8(iid): 7(ptr) Variable Function + 16(viewID): 7(ptr) Variable Function + 14: 13(ptr) AccessChain 11(gl_LocalInvocationID) 12 + 15: 6(int) Load 14 + Store 8(iid) 15 + 22: 6(int) Load 21(gl_MeshViewCountNV) + 23: 6(int) UMod 22 17 + 24: 13(ptr) AccessChain 20(gl_MeshViewIndicesNV) 23 + 25: 6(int) Load 24 + Store 16(viewID) 25 + 36: 6(int) Load 8(iid) + 39: 6(int) Load 16(viewID) + 44: 43(ptr) AccessChain 35(b) 36 38 39 40 + Store 44 42 + 45: 6(int) Load 8(iid) + 49: 43(ptr) AccessChain 35(b) 45 46 46 + Store 49 48 + 50: 6(int) Load 8(iid) + 51: 6(int) Load 16(viewID) + 54: 43(ptr) AccessChain 35(b) 50 40 51 40 + Store 54 53 + 55: 6(int) Load 8(iid) + 59: 43(ptr) AccessChain 35(b) 55 56 + Store 59 58 + MemoryBarrier 60 61 + ControlBarrier 62 62 61 + 68: 6(int) Load 8(iid) + 69: 6(int) Load 16(viewID) + 72: 43(ptr) AccessChain 67(b2) 68 38 69 + Store 72 71 + 73: 6(int) Load 8(iid) + 74: 6(int) Load 16(viewID) + 77: 43(ptr) AccessChain 67(b2) 73 46 74 46 + Store 77 76 + 78: 6(int) Load 8(iid) + 79: 6(int) Load 16(viewID) + 82: 43(ptr) AccessChain 67(b2) 78 40 79 40 + Store 82 81 + 83: 6(int) Load 8(iid) + 84: 6(int) Load 16(viewID) + 87: 43(ptr) AccessChain 67(b2) 83 56 84 + Store 87 86 + MemoryBarrier 60 61 + ControlBarrier 62 62 61 + Return + FunctionEnd diff --git a/Test/baseResults/spv.meshShaderSharedMem.mesh.out b/Test/baseResults/spv.meshShaderSharedMem.mesh.out new file mode 100644 index 000000000..198f8129a --- /dev/null +++ b/Test/baseResults/spv.meshShaderSharedMem.mesh.out @@ -0,0 +1,128 @@ +spv.meshShaderSharedMem.mesh +// Module Version 10000 +// Generated by (magic number): 80007 +// Id's are bound by 77 + + Capability StorageImageWriteWithoutFormat + Capability MeshShadingNV + Extension "SPV_NV_mesh_shader" + 1: ExtInstImport "GLSL.std.450" + MemoryModel Logical GLSL450 + EntryPoint MeshNV 4 "main" 11 17 + ExecutionMode 4 LocalSize 32 1 1 + ExecutionMode 4 OutputVertices 81 + ExecutionMode 4 OutputPrimitivesNV 32 + ExecutionMode 4 OutputTrianglesNV + Source GLSL 450 + SourceExtension "GL_NV_mesh_shader" + Name 4 "main" + Name 8 "iid" + Name 11 "gl_LocalInvocationID" + Name 16 "gid" + Name 17 "gl_WorkGroupID" + Name 20 "i" + Name 34 "mem" + Name 37 "block0" + MemberName 37(block0) 0 "uni_value" + Name 39 "" + Name 55 "uni_image" + Decorate 11(gl_LocalInvocationID) BuiltIn LocalInvocationId + Decorate 17(gl_WorkGroupID) BuiltIn WorkgroupId + MemberDecorate 37(block0) 0 Offset 0 + Decorate 37(block0) Block + Decorate 39 DescriptorSet 0 + Decorate 55(uni_image) DescriptorSet 0 + Decorate 55(uni_image) NonReadable + Decorate 76 BuiltIn WorkgroupSize + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeInt 32 0 + 7: TypePointer Function 6(int) + 9: TypeVector 6(int) 3 + 10: TypePointer Input 9(ivec3) +11(gl_LocalInvocationID): 10(ptr) Variable Input + 12: 6(int) Constant 0 + 13: TypePointer Input 6(int) +17(gl_WorkGroupID): 10(ptr) Variable Input + 27: 6(int) Constant 10 + 28: TypeBool + 30: TypeFloat 32 + 31: TypeVector 30(float) 4 + 32: TypeArray 31(fvec4) 27 + 33: TypePointer Workgroup 32 + 34(mem): 33(ptr) Variable Workgroup + 37(block0): TypeStruct 6(int) + 38: TypePointer Uniform 37(block0) + 39: 38(ptr) Variable Uniform + 40: TypeInt 32 1 + 41: 40(int) Constant 0 + 42: TypePointer Uniform 6(int) + 48: TypePointer Workgroup 31(fvec4) + 51: 40(int) Constant 1 + 53: TypeImage 30(float) 2D nonsampled format:Unknown + 54: TypePointer UniformConstant 53 + 55(uni_image): 54(ptr) Variable UniformConstant + 59: TypeVector 40(int) 2 + 69: 6(int) Constant 1 + 73: 6(int) Constant 264 + 74: 6(int) Constant 2 + 75: 6(int) Constant 32 + 76: 9(ivec3) ConstantComposite 75 69 69 + 4(main): 2 Function None 3 + 5: Label + 8(iid): 7(ptr) Variable Function + 16(gid): 7(ptr) Variable Function + 20(i): 7(ptr) Variable Function + 14: 13(ptr) AccessChain 11(gl_LocalInvocationID) 12 + 15: 6(int) Load 14 + Store 8(iid) 15 + 18: 13(ptr) AccessChain 17(gl_WorkGroupID) 12 + 19: 6(int) Load 18 + Store 16(gid) 19 + Store 20(i) 12 + Branch 21 + 21: Label + LoopMerge 23 24 None + Branch 25 + 25: Label + 26: 6(int) Load 20(i) + 29: 28(bool) ULessThan 26 27 + BranchConditional 29 22 23 + 22: Label + 35: 6(int) Load 20(i) + 36: 6(int) Load 20(i) + 43: 42(ptr) AccessChain 39 41 + 44: 6(int) Load 43 + 45: 6(int) IAdd 36 44 + 46: 30(float) ConvertUToF 45 + 47: 31(fvec4) CompositeConstruct 46 46 46 46 + 49: 48(ptr) AccessChain 34(mem) 35 + Store 49 47 + Branch 24 + 24: Label + 50: 6(int) Load 20(i) + 52: 6(int) IAdd 50 51 + Store 20(i) 52 + Branch 21 + 23: Label + 56: 53 Load 55(uni_image) + 57: 6(int) Load 8(iid) + 58: 40(int) Bitcast 57 + 60: 59(ivec2) CompositeConstruct 58 58 + 61: 6(int) Load 16(gid) + 62: 48(ptr) AccessChain 34(mem) 61 + 63: 31(fvec4) Load 62 + ImageWrite 56 60 63 + 64: 53 Load 55(uni_image) + 65: 6(int) Load 8(iid) + 66: 40(int) Bitcast 65 + 67: 59(ivec2) CompositeConstruct 66 66 + 68: 6(int) Load 16(gid) + 70: 6(int) IAdd 68 69 + 71: 48(ptr) AccessChain 34(mem) 70 + 72: 31(fvec4) Load 71 + ImageWrite 64 67 72 + MemoryBarrier 69 73 + ControlBarrier 74 74 73 + Return + FunctionEnd diff --git a/Test/baseResults/spv.meshShaderTaskMem.mesh.out b/Test/baseResults/spv.meshShaderTaskMem.mesh.out new file mode 100644 index 000000000..93b2a457c --- /dev/null +++ b/Test/baseResults/spv.meshShaderTaskMem.mesh.out @@ -0,0 +1,107 @@ +spv.meshShaderTaskMem.mesh +// Module Version 10000 +// Generated by (magic number): 80007 +// Id's are bound by 58 + + Capability MeshShadingNV + Extension "SPV_NV_mesh_shader" + 1: ExtInstImport "GLSL.std.450" + MemoryModel Logical GLSL450 + EntryPoint MeshNV 4 "main" 11 22 30 + ExecutionMode 4 LocalSize 32 1 1 + ExecutionMode 4 OutputVertices 81 + ExecutionMode 4 OutputPrimitivesNV 32 + ExecutionMode 4 OutputTrianglesNV + Source GLSL 450 + SourceExtension "GL_NV_mesh_shader" + Name 4 "main" + Name 8 "iid" + Name 11 "gl_LocalInvocationID" + Name 18 "outBlock" + MemberName 18(outBlock) 0 "gid5" + MemberName 18(outBlock) 1 "gid6" + Name 22 "myblk" + Name 28 "taskBlock" + MemberName 28(taskBlock) 0 "gid1" + MemberName 28(taskBlock) 1 "gid2" + Name 30 "mytask" + Name 36 "bufferBlock" + MemberName 36(bufferBlock) 0 "gid3" + MemberName 36(bufferBlock) 1 "gid4" + Name 38 "mybuf" + Decorate 11(gl_LocalInvocationID) BuiltIn LocalInvocationId + Decorate 18(outBlock) Block + Decorate 22(myblk) Location 0 + Decorate 27 ArrayStride 4 + MemberDecorate 28(taskBlock) 0 PerTaskNV + MemberDecorate 28(taskBlock) 0 Offset 0 + MemberDecorate 28(taskBlock) 1 PerTaskNV + MemberDecorate 28(taskBlock) 1 Offset 16 + Decorate 28(taskBlock) Block + Decorate 35 ArrayStride 4 + MemberDecorate 36(bufferBlock) 0 Offset 0 + MemberDecorate 36(bufferBlock) 1 Offset 16 + Decorate 36(bufferBlock) BufferBlock + Decorate 38(mybuf) DescriptorSet 0 + Decorate 57 BuiltIn WorkgroupSize + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeInt 32 0 + 7: TypePointer Function 6(int) + 9: TypeVector 6(int) 3 + 10: TypePointer Input 9(ivec3) +11(gl_LocalInvocationID): 10(ptr) Variable Input + 12: 6(int) Constant 0 + 13: TypePointer Input 6(int) + 16: TypeFloat 32 + 17: TypeVector 16(float) 4 + 18(outBlock): TypeStruct 16(float) 17(fvec4) + 19: 6(int) Constant 81 + 20: TypeArray 18(outBlock) 19 + 21: TypePointer Output 20 + 22(myblk): 21(ptr) Variable Output + 24: TypeInt 32 1 + 25: 24(int) Constant 0 + 26: 6(int) Constant 2 + 27: TypeArray 16(float) 26 + 28(taskBlock): TypeStruct 27 17(fvec4) + 29: TypePointer Input 28(taskBlock) + 30(mytask): 29(ptr) Variable Input + 31: 24(int) Constant 1 + 32: TypePointer Input 16(float) + 35: TypeArray 16(float) 26 + 36(bufferBlock): TypeStruct 35 17(fvec4) + 37: TypePointer Uniform 36(bufferBlock) + 38(mybuf): 37(ptr) Variable Uniform + 39: TypePointer Uniform 16(float) + 43: TypePointer Output 16(float) + 46: TypePointer Input 17(fvec4) + 49: TypePointer Uniform 17(fvec4) + 53: TypePointer Output 17(fvec4) + 55: 6(int) Constant 32 + 56: 6(int) Constant 1 + 57: 9(ivec3) ConstantComposite 55 56 56 + 4(main): 2 Function None 3 + 5: Label + 8(iid): 7(ptr) Variable Function + 14: 13(ptr) AccessChain 11(gl_LocalInvocationID) 12 + 15: 6(int) Load 14 + Store 8(iid) 15 + 23: 6(int) Load 8(iid) + 33: 32(ptr) AccessChain 30(mytask) 25 31 + 34: 16(float) Load 33 + 40: 39(ptr) AccessChain 38(mybuf) 25 31 + 41: 16(float) Load 40 + 42: 16(float) FAdd 34 41 + 44: 43(ptr) AccessChain 22(myblk) 23 25 + Store 44 42 + 45: 6(int) Load 8(iid) + 47: 46(ptr) AccessChain 30(mytask) 31 + 48: 17(fvec4) Load 47 + 50: 49(ptr) AccessChain 38(mybuf) 31 + 51: 17(fvec4) Load 50 + 52: 17(fvec4) FAdd 48 51 + 54: 53(ptr) AccessChain 22(myblk) 45 31 + Store 54 52 + Return + FunctionEnd diff --git a/Test/baseResults/spv.meshShaderUserDefined.mesh.out b/Test/baseResults/spv.meshShaderUserDefined.mesh.out new file mode 100644 index 000000000..c3ec91507 --- /dev/null +++ b/Test/baseResults/spv.meshShaderUserDefined.mesh.out @@ -0,0 +1,203 @@ +spv.meshShaderUserDefined.mesh +// Module Version 10000 +// Generated by (magic number): 80007 +// Id's are bound by 138 + + Capability MeshShadingNV + Extension "SPV_NV_mesh_shader" + 1: ExtInstImport "GLSL.std.450" + MemoryModel Logical GLSL450 + EntryPoint MeshNV 4 "main" 11 17 34 101 + ExecutionMode 4 LocalSize 32 1 1 + ExecutionMode 4 OutputVertices 81 + ExecutionMode 4 OutputPrimitivesNV 32 + ExecutionMode 4 OutputTrianglesNV + Source GLSL 450 + SourceExtension "GL_NV_mesh_shader" + Name 4 "main" + Name 8 "iid" + Name 11 "gl_LocalInvocationID" + Name 16 "gid" + Name 17 "gl_WorkGroupID" + Name 30 "myblock" + MemberName 30(myblock) 0 "f" + MemberName 30(myblock) 1 "fArr" + MemberName 30(myblock) 2 "pos" + MemberName 30(myblock) 3 "posArr" + MemberName 30(myblock) 4 "m" + MemberName 30(myblock) 5 "mArr" + Name 34 "blk" + Name 97 "myblock2" + MemberName 97(myblock2) 0 "f" + MemberName 97(myblock2) 1 "pos" + MemberName 97(myblock2) 2 "m" + Name 101 "blk2" + Decorate 11(gl_LocalInvocationID) BuiltIn LocalInvocationId + Decorate 17(gl_WorkGroupID) BuiltIn WorkgroupId + MemberDecorate 30(myblock) 0 PerPrimitiveNV + MemberDecorate 30(myblock) 1 PerPrimitiveNV + MemberDecorate 30(myblock) 2 PerPrimitiveNV + MemberDecorate 30(myblock) 3 PerPrimitiveNV + MemberDecorate 30(myblock) 4 PerPrimitiveNV + MemberDecorate 30(myblock) 5 PerPrimitiveNV + Decorate 30(myblock) Block + Decorate 34(blk) Location 0 + Decorate 97(myblock2) Block + Decorate 101(blk2) Location 20 + Decorate 137 BuiltIn WorkgroupSize + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeInt 32 0 + 7: TypePointer Function 6(int) + 9: TypeVector 6(int) 3 + 10: TypePointer Input 9(ivec3) +11(gl_LocalInvocationID): 10(ptr) Variable Input + 12: 6(int) Constant 0 + 13: TypePointer Input 6(int) +17(gl_WorkGroupID): 10(ptr) Variable Input + 20: TypeFloat 32 + 21: 6(int) Constant 4 + 22: TypeArray 20(float) 21 + 23: TypeVector 20(float) 3 + 24: TypeVector 20(float) 4 + 25: TypeArray 24(fvec4) 21 + 26: TypeMatrix 24(fvec4) 4 + 27: TypeMatrix 23(fvec3) 3 + 28: 6(int) Constant 2 + 29: TypeArray 27 28 + 30(myblock): TypeStruct 20(float) 22 23(fvec3) 25 26 29 + 31: 6(int) Constant 32 + 32: TypeArray 30(myblock) 31 + 33: TypePointer Output 32 + 34(blk): 33(ptr) Variable Output + 36: TypeInt 32 1 + 37: 36(int) Constant 0 + 38: 20(float) Constant 1093664768 + 39: TypePointer Output 20(float) + 42: 6(int) Constant 1 + 44: 36(int) Constant 1 + 52: 36(int) Constant 2 + 53: 20(float) Constant 1096810496 + 54: 20(float) Constant 1097859072 + 55: 20(float) Constant 1095761920 + 56: 23(fvec3) ConstantComposite 53 54 55 + 57: TypePointer Output 23(fvec3) + 63: 36(int) Constant 3 + 68: TypePointer Output 24(fvec4) + 74: 36(int) Constant 4 + 75: 20(float) Constant 1098907648 + 76: 24(fvec4) ConstantComposite 55 53 54 75 + 81: 36(int) Constant 5 + 84: 6(int) Constant 3 + 91: 20(float) Constant 1099431936 + 92: 20(float) Constant 1099956224 + 93: 20(float) Constant 1100480512 + 94: 23(fvec3) ConstantComposite 91 92 93 + 96: 6(int) Constant 264 + 97(myblock2): TypeStruct 20(float) 24(fvec4) 26 + 98: 6(int) Constant 81 + 99: TypeArray 97(myblock2) 98 + 100: TypePointer Output 99 + 101(blk2): 100(ptr) Variable Output + 107: 20(float) Constant 1101004800 + 111: 20(float) Constant 1101529088 + 112: 20(float) Constant 1102053376 + 113: 20(float) Constant 1102577664 + 114: 20(float) Constant 1103101952 + 115: 24(fvec4) ConstantComposite 111 112 113 114 + 127: 20(float) Constant 1105723392 + 137: 9(ivec3) ConstantComposite 31 42 42 + 4(main): 2 Function None 3 + 5: Label + 8(iid): 7(ptr) Variable Function + 16(gid): 7(ptr) Variable Function + 14: 13(ptr) AccessChain 11(gl_LocalInvocationID) 12 + 15: 6(int) Load 14 + Store 8(iid) 15 + 18: 13(ptr) AccessChain 17(gl_WorkGroupID) 12 + 19: 6(int) Load 18 + Store 16(gid) 19 + 35: 6(int) Load 8(iid) + 40: 39(ptr) AccessChain 34(blk) 35 37 + Store 40 38 + 41: 6(int) Load 8(iid) + 43: 6(int) IAdd 41 42 + 45: 6(int) Load 16(gid) + 46: 6(int) Load 8(iid) + 47: 39(ptr) AccessChain 34(blk) 46 37 + 48: 20(float) Load 47 + 49: 39(ptr) AccessChain 34(blk) 43 44 45 + Store 49 48 + 50: 6(int) Load 8(iid) + 51: 6(int) UDiv 50 28 + 58: 57(ptr) AccessChain 34(blk) 51 52 + 59: 23(fvec3) Load 58 + 60: 23(fvec3) VectorShuffle 59 56 5 3 4 + Store 58 60 + 61: 6(int) Load 8(iid) + 62: 6(int) IMul 61 28 + 64: 6(int) Load 8(iid) + 65: 6(int) UDiv 64 28 + 66: 57(ptr) AccessChain 34(blk) 65 52 + 67: 23(fvec3) Load 66 + 69: 68(ptr) AccessChain 34(blk) 62 63 44 + 70: 24(fvec4) Load 69 + 71: 24(fvec4) VectorShuffle 70 67 0 4 5 6 + Store 69 71 + 72: 6(int) Load 8(iid) + 73: 6(int) UDiv 72 21 + 77: 68(ptr) AccessChain 34(blk) 73 74 52 + 78: 24(fvec4) Load 77 + 79: 24(fvec4) VectorShuffle 78 76 7 6 5 4 + Store 77 79 + 80: 6(int) Load 8(iid) + 82: 6(int) Load 8(iid) + 83: 6(int) UDiv 82 21 + 85: 39(ptr) AccessChain 34(blk) 83 74 52 84 + 86: 20(float) Load 85 + 87: 39(ptr) AccessChain 34(blk) 80 81 37 44 42 + Store 87 86 + 88: 6(int) Load 8(iid) + 89: 6(int) IMul 88 21 + 90: 6(int) Load 16(gid) + 95: 57(ptr) AccessChain 34(blk) 89 81 44 90 + Store 95 94 + MemoryBarrier 42 96 + ControlBarrier 28 28 96 + 102: 6(int) Load 8(iid) + 103: 6(int) Load 8(iid) + 104: 6(int) ISub 103 42 + 105: 39(ptr) AccessChain 101(blk2) 104 37 + 106: 20(float) Load 105 + 108: 20(float) FAdd 106 107 + 109: 39(ptr) AccessChain 101(blk2) 102 37 + Store 109 108 + 110: 6(int) Load 8(iid) + 116: 68(ptr) AccessChain 101(blk2) 110 44 + Store 116 115 + 117: 6(int) Load 8(iid) + 118: 6(int) IAdd 117 42 + 119: 6(int) Load 16(gid) + 120: 6(int) Load 8(iid) + 121: 68(ptr) AccessChain 101(blk2) 120 44 + 122: 24(fvec4) Load 121 + 123: 68(ptr) AccessChain 101(blk2) 118 52 119 + Store 123 122 + 124: 6(int) Load 8(iid) + 125: 6(int) IAdd 124 42 + 126: 6(int) Load 16(gid) + 128: 39(ptr) AccessChain 101(blk2) 125 52 126 28 + Store 128 127 + 129: 6(int) Load 8(iid) + 130: 6(int) IAdd 129 28 + 131: 6(int) Load 8(iid) + 132: 6(int) IAdd 131 42 + 133: 6(int) Load 16(gid) + 134: 68(ptr) AccessChain 101(blk2) 132 52 133 + 135: 24(fvec4) Load 134 + 136: 68(ptr) AccessChain 101(blk2) 130 52 63 + Store 136 135 + MemoryBarrier 42 96 + ControlBarrier 28 28 96 + Return + FunctionEnd diff --git a/Test/baseResults/spv.meshTaskShader.task.out b/Test/baseResults/spv.meshTaskShader.task.out new file mode 100644 index 000000000..9ac27fa9b --- /dev/null +++ b/Test/baseResults/spv.meshTaskShader.task.out @@ -0,0 +1,172 @@ +spv.meshTaskShader.task +// Module Version 10000 +// Generated by (magic number): 80007 +// Id's are bound by 104 + + Capability StorageImageWriteWithoutFormat + Capability MeshShadingNV + Extension "SPV_NV_mesh_shader" + 1: ExtInstImport "GLSL.std.450" + MemoryModel Logical GLSL450 + EntryPoint TaskNV 4 "main" 11 17 80 101 + ExecutionMode 4 LocalSize 32 1 1 + Source GLSL 450 + SourceExtension "GL_NV_mesh_shader" + Name 4 "main" + Name 8 "iid" + Name 11 "gl_LocalInvocationID" + Name 16 "gid" + Name 17 "gl_WorkGroupID" + Name 20 "i" + Name 34 "mem" + Name 37 "block0" + MemberName 37(block0) 0 "uni_value" + Name 39 "" + Name 55 "uni_image" + Name 78 "Task" + MemberName 78(Task) 0 "dummy" + MemberName 78(Task) 1 "submesh" + Name 80 "mytask" + Name 101 "gl_TaskCountNV" + Decorate 11(gl_LocalInvocationID) BuiltIn LocalInvocationId + Decorate 17(gl_WorkGroupID) BuiltIn WorkgroupId + MemberDecorate 37(block0) 0 Offset 0 + Decorate 37(block0) Block + Decorate 39 DescriptorSet 0 + Decorate 55(uni_image) DescriptorSet 0 + Decorate 55(uni_image) Binding 0 + Decorate 55(uni_image) NonReadable + Decorate 77 ArrayStride 8 + MemberDecorate 78(Task) 0 PerTaskNV + MemberDecorate 78(Task) 0 Offset 0 + MemberDecorate 78(Task) 1 PerTaskNV + MemberDecorate 78(Task) 1 Offset 8 + Decorate 78(Task) Block + Decorate 101(gl_TaskCountNV) BuiltIn TaskCountNV + Decorate 103 BuiltIn WorkgroupSize + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeInt 32 0 + 7: TypePointer Function 6(int) + 9: TypeVector 6(int) 3 + 10: TypePointer Input 9(ivec3) +11(gl_LocalInvocationID): 10(ptr) Variable Input + 12: 6(int) Constant 0 + 13: TypePointer Input 6(int) +17(gl_WorkGroupID): 10(ptr) Variable Input + 27: 6(int) Constant 10 + 28: TypeBool + 30: TypeFloat 32 + 31: TypeVector 30(float) 4 + 32: TypeArray 31(fvec4) 27 + 33: TypePointer Workgroup 32 + 34(mem): 33(ptr) Variable Workgroup + 37(block0): TypeStruct 6(int) + 38: TypePointer Uniform 37(block0) + 39: 38(ptr) Variable Uniform + 40: TypeInt 32 1 + 41: 40(int) Constant 0 + 42: TypePointer Uniform 6(int) + 48: TypePointer Workgroup 31(fvec4) + 51: 40(int) Constant 1 + 53: TypeImage 30(float) 2D nonsampled format:Unknown + 54: TypePointer UniformConstant 53 + 55(uni_image): 54(ptr) Variable UniformConstant + 59: TypeVector 40(int) 2 + 69: 6(int) Constant 1 + 73: 6(int) Constant 264 + 74: 6(int) Constant 2 + 75: TypeVector 30(float) 2 + 76: 6(int) Constant 3 + 77: TypeArray 75(fvec2) 76 + 78(Task): TypeStruct 75(fvec2) 77 + 79: TypePointer Output 78(Task) + 80(mytask): 79(ptr) Variable Output + 81: 30(float) Constant 1106247680 + 82: 30(float) Constant 1106771968 + 83: 75(fvec2) ConstantComposite 81 82 + 84: TypePointer Output 75(fvec2) + 86: 30(float) Constant 1107296256 + 87: 30(float) Constant 1107558400 + 88: 75(fvec2) ConstantComposite 86 87 + 90: 30(float) Constant 1107820544 + 91: 30(float) Constant 1108082688 + 92: 75(fvec2) ConstantComposite 90 91 + 94: 40(int) Constant 2 + 100: TypePointer Output 6(int) +101(gl_TaskCountNV): 100(ptr) Variable Output + 102: 6(int) Constant 32 + 103: 9(ivec3) ConstantComposite 102 69 69 + 4(main): 2 Function None 3 + 5: Label + 8(iid): 7(ptr) Variable Function + 16(gid): 7(ptr) Variable Function + 20(i): 7(ptr) Variable Function + 14: 13(ptr) AccessChain 11(gl_LocalInvocationID) 12 + 15: 6(int) Load 14 + Store 8(iid) 15 + 18: 13(ptr) AccessChain 17(gl_WorkGroupID) 12 + 19: 6(int) Load 18 + Store 16(gid) 19 + Store 20(i) 12 + Branch 21 + 21: Label + LoopMerge 23 24 None + Branch 25 + 25: Label + 26: 6(int) Load 20(i) + 29: 28(bool) ULessThan 26 27 + BranchConditional 29 22 23 + 22: Label + 35: 6(int) Load 20(i) + 36: 6(int) Load 20(i) + 43: 42(ptr) AccessChain 39 41 + 44: 6(int) Load 43 + 45: 6(int) IAdd 36 44 + 46: 30(float) ConvertUToF 45 + 47: 31(fvec4) CompositeConstruct 46 46 46 46 + 49: 48(ptr) AccessChain 34(mem) 35 + Store 49 47 + Branch 24 + 24: Label + 50: 6(int) Load 20(i) + 52: 6(int) IAdd 50 51 + Store 20(i) 52 + Branch 21 + 23: Label + 56: 53 Load 55(uni_image) + 57: 6(int) Load 8(iid) + 58: 40(int) Bitcast 57 + 60: 59(ivec2) CompositeConstruct 58 58 + 61: 6(int) Load 16(gid) + 62: 48(ptr) AccessChain 34(mem) 61 + 63: 31(fvec4) Load 62 + ImageWrite 56 60 63 + 64: 53 Load 55(uni_image) + 65: 6(int) Load 8(iid) + 66: 40(int) Bitcast 65 + 67: 59(ivec2) CompositeConstruct 66 66 + 68: 6(int) Load 16(gid) + 70: 6(int) IAdd 68 69 + 71: 48(ptr) AccessChain 34(mem) 70 + 72: 31(fvec4) Load 71 + ImageWrite 64 67 72 + MemoryBarrier 69 73 + ControlBarrier 74 74 73 + 85: 84(ptr) AccessChain 80(mytask) 41 + Store 85 83 + 89: 84(ptr) AccessChain 80(mytask) 51 41 + Store 89 88 + 93: 84(ptr) AccessChain 80(mytask) 51 51 + Store 93 92 + 95: 6(int) Load 16(gid) + 96: 6(int) UMod 95 74 + 97: 84(ptr) AccessChain 80(mytask) 51 96 + 98: 75(fvec2) Load 97 + 99: 84(ptr) AccessChain 80(mytask) 51 94 + Store 99 98 + MemoryBarrier 69 73 + ControlBarrier 74 74 73 + Store 101(gl_TaskCountNV) 76 + Return + FunctionEnd diff --git a/Test/baseResults/test.conf b/Test/baseResults/test.conf index f156c5c6d..cff77168a 100644 --- a/Test/baseResults/test.conf +++ b/Test/baseResults/test.conf @@ -81,6 +81,15 @@ MaxTransformFeedbackInterleavedComponents 64 MaxCullDistances 8 MaxCombinedClipAndCullDistances 8 MaxSamples 4 +MaxMeshOutputVerticesNV 256 +MaxMeshOutputPrimitivesNV 512 +MaxMeshWorkGroupSizeX_NV 32 +MaxMeshWorkGroupSizeY_NV 1 +MaxMeshWorkGroupSizeZ_NV 1 +MaxTaskWorkGroupSizeX_NV 32 +MaxTaskWorkGroupSizeY_NV 1 +MaxTaskWorkGroupSizeZ_NV 1 +MaxMeshViewCountNV 4 nonInductiveForLoops 1 whileLoops 1 doWhileLoops 1 diff --git a/Test/spv.meshShaderBuiltins.mesh b/Test/spv.meshShaderBuiltins.mesh new file mode 100644 index 000000000..8adff3d82 --- /dev/null +++ b/Test/spv.meshShaderBuiltins.mesh @@ -0,0 +1,63 @@ +#version 460 + +#define MAX_VER 81 +#define MAX_PRIM 32 + +#define BARRIER() \ + memoryBarrierShared(); \ + barrier(); + +#extension GL_NV_mesh_shader : enable + +layout(local_size_x = 32) in; + +layout(max_vertices=MAX_VER) out; +layout(max_primitives=MAX_PRIM) out; +layout(triangles) out; + +// test use of builtins in mesh shaders: + +void main() +{ + uint iid = gl_LocalInvocationID.x; + uint gid = gl_WorkGroupID.x; + + gl_MeshVerticesNV[iid].gl_Position = vec4(1.0); + gl_MeshVerticesNV[iid].gl_PointSize = 2.0; + gl_MeshVerticesNV[iid].gl_ClipDistance[3] = 3.0; + gl_MeshVerticesNV[iid].gl_CullDistance[2] = 4.0; + + BARRIER(); + + gl_MeshVerticesNV[iid+1].gl_Position = gl_MeshVerticesNV[iid].gl_Position; + gl_MeshVerticesNV[iid+1].gl_PointSize = gl_MeshVerticesNV[iid].gl_PointSize; + gl_MeshVerticesNV[iid+1].gl_ClipDistance[3] = gl_MeshVerticesNV[iid].gl_ClipDistance[3]; + gl_MeshVerticesNV[iid+1].gl_CullDistance[2] = gl_MeshVerticesNV[iid].gl_CullDistance[2]; + + BARRIER(); + + gl_MeshPrimitivesNV[iid].gl_PrimitiveID = 6; + gl_MeshPrimitivesNV[iid].gl_Layer = 7; + gl_MeshPrimitivesNV[iid].gl_ViewportIndex = 8; + gl_MeshPrimitivesNV[iid].gl_ViewportMask[0] = 9; + + BARRIER(); + + gl_MeshPrimitivesNV[iid+1].gl_PrimitiveID = gl_MeshPrimitivesNV[iid].gl_PrimitiveID; + gl_MeshPrimitivesNV[iid+1].gl_Layer = gl_MeshPrimitivesNV[iid].gl_Layer; + gl_MeshPrimitivesNV[iid+1].gl_ViewportIndex = gl_MeshPrimitivesNV[iid].gl_ViewportIndex; + gl_MeshPrimitivesNV[iid+1].gl_ViewportMask[0] = gl_MeshPrimitivesNV[iid].gl_ViewportMask[0]; + + BARRIER(); + + // should truncate 257 -> 1 + gl_PrimitiveIndicesNV[0] = 257; + gl_PrimitiveIndicesNV[gid] = gl_PrimitiveIndicesNV[gid-1]; + + // writes 4 indices at offset gl_DrawID + writePackedPrimitiveIndices4x8NV(gl_DrawID, 0x01020304); + + gl_PrimitiveCountNV = MAX_PRIM * 3; + + BARRIER(); +} diff --git a/Test/spv.meshShaderPerViewBuiltins.mesh b/Test/spv.meshShaderPerViewBuiltins.mesh new file mode 100644 index 000000000..54fb74408 --- /dev/null +++ b/Test/spv.meshShaderPerViewBuiltins.mesh @@ -0,0 +1,42 @@ +#version 450 + +#define MAX_VER 81 +#define MAX_PRIM 32 +#define MAX_VIEWS gl_MaxMeshViewCountNV + +#define BARRIER() \ + memoryBarrierShared(); \ + barrier(); + +#extension GL_NV_mesh_shader : enable + +layout(local_size_x = 32) in; + +layout(max_vertices=MAX_VER) out; +layout(max_primitives=MAX_PRIM) out; +layout(triangles) out; + +// test use of per-view builtin attributes + +void main() +{ + uint iid = gl_LocalInvocationID.x; + uint viewID = gl_MeshViewIndicesNV[gl_MeshViewCountNV%MAX_VIEWS]; + + gl_MeshVerticesNV[iid].gl_PositionPerViewNV[viewID] = vec4(1.0, 2.0, 3.0, 4.0); + gl_MeshVerticesNV[iid].gl_ClipDistancePerViewNV[viewID][2] = 5.0; + gl_MeshVerticesNV[iid].gl_CullDistancePerViewNV[viewID][3] = 6.0; + gl_MeshPrimitivesNV[iid].gl_LayerPerViewNV[viewID] = 7; + gl_MeshPrimitivesNV[iid].gl_ViewportMaskPerViewNV[viewID][0] = 8; + + BARRIER(); + + gl_MeshVerticesNV[iid+1].gl_PositionPerViewNV[viewID] = gl_MeshVerticesNV[iid].gl_PositionPerViewNV[viewID]; + gl_MeshVerticesNV[iid+1].gl_ClipDistancePerViewNV[viewID][2] = gl_MeshVerticesNV[iid].gl_ClipDistancePerViewNV[viewID][2]; + gl_MeshVerticesNV[iid+1].gl_CullDistancePerViewNV[viewID][3] = gl_MeshVerticesNV[iid].gl_CullDistancePerViewNV[viewID][3]; + gl_MeshPrimitivesNV[iid+1].gl_LayerPerViewNV[viewID] = gl_MeshPrimitivesNV[iid].gl_LayerPerViewNV[viewID]; + gl_MeshPrimitivesNV[iid+1].gl_ViewportMaskPerViewNV[viewID][0] = gl_MeshPrimitivesNV[iid].gl_ViewportMaskPerViewNV[viewID][0]; + + BARRIER(); +} + diff --git a/Test/spv.meshShaderPerViewUserDefined.mesh b/Test/spv.meshShaderPerViewUserDefined.mesh new file mode 100644 index 000000000..4a316eb24 --- /dev/null +++ b/Test/spv.meshShaderPerViewUserDefined.mesh @@ -0,0 +1,56 @@ +#version 450 + +#define MAX_VER 81 +#define MAX_PRIM 32 +#define MAX_VIEWS gl_MaxMeshViewCountNV + +#define BARRIER() \ + memoryBarrierShared(); \ + barrier(); + +#extension GL_NV_mesh_shader : enable + +layout(local_size_x = 32) in; + +layout(max_vertices=MAX_VER) out; +layout(max_primitives=MAX_PRIM) out; +layout(triangles) out; + +// test use of user-defined per-view attributes + +// mix of single-view and per-view attributes +layout(location=0) out block { + perprimitiveNV perviewNV vec4 color1[][3]; // Implicitly sized + perprimitiveNV vec4 color2[3]; + perviewNV vec4 color3[MAX_VIEWS][3]; // Explicitly sized + vec4 color4; +} b[]; + +// per-view block +perviewNV layout(location=10) out perviewBlock { + perprimitiveNV vec4 color5[]; // Implicitly sized + perprimitiveNV vec4 color6[MAX_VIEWS][3]; // Explicitly sized + vec4 color7[][3]; // Implicitly sized + vec4 color8[MAX_VIEWS]; // Explicitly sized +} b2[]; + +void main() +{ + uint iid = gl_LocalInvocationID.x; + uint viewID = gl_MeshViewIndicesNV[gl_MeshViewCountNV%MAX_VIEWS]; + + b[iid].color1[viewID][2] = vec4(1.0); + b[iid].color2[1] = vec4(2.0); + b[iid].color3[viewID][2] = vec4(3.0); + b[iid].color4 = vec4(4.0); + + BARRIER(); + + b2[iid].color5[viewID] = vec4(5.0); + b2[iid].color6[viewID][1] = vec4(6.0); + b2[iid].color7[viewID][2] = vec4(7.0); + b2[iid].color8[viewID] = vec4(8.0); + + BARRIER(); +} + diff --git a/Test/spv.meshShaderSharedMem.mesh b/Test/spv.meshShaderSharedMem.mesh new file mode 100644 index 000000000..b9d2f6d7e --- /dev/null +++ b/Test/spv.meshShaderSharedMem.mesh @@ -0,0 +1,39 @@ +#version 450 + +#define MAX_VER 81 +#define MAX_PRIM 32 + +#define BARRIER() \ + memoryBarrierShared(); \ + barrier(); + +#extension GL_NV_mesh_shader : enable + +layout(local_size_x = 32) in; + +layout(max_vertices=MAX_VER) out; +layout(max_primitives=MAX_PRIM) out; +layout(triangles) out; + +// test use of shared memory in mesh shaders: + +writeonly uniform image2D uni_image; +uniform block0 { + uint uni_value; +}; + +shared vec4 mem[10]; + +void main() +{ + uint iid = gl_LocalInvocationID.x; + uint gid = gl_WorkGroupID.x; + + for (uint i = 0; i < 10; ++i) { + mem[i] = vec4(i+uni_value); + } + imageStore(uni_image, ivec2(iid), mem[gid]); + imageStore(uni_image, ivec2(iid), mem[gid+1]); + + BARRIER(); +} diff --git a/Test/spv.meshShaderTaskMem.mesh b/Test/spv.meshShaderTaskMem.mesh new file mode 100644 index 000000000..5ce5beddc --- /dev/null +++ b/Test/spv.meshShaderTaskMem.mesh @@ -0,0 +1,41 @@ +#version 450 + +#define MAX_VER 81 +#define MAX_PRIM 32 + +#define BARRIER() \ + memoryBarrierShared(); \ + barrier(); + +#extension GL_NV_mesh_shader : enable + +layout(local_size_x = 32) in; + +layout(max_vertices=MAX_VER) out; +layout(max_primitives=MAX_PRIM) out; +layout(triangles) out; + +// test use of task memory in mesh shaders: + +taskNV in taskBlock { + float gid1[2]; + vec4 gid2; +} mytask; + +buffer bufferBlock { + float gid3[2]; + vec4 gid4; +} mybuf; + +layout(location=0) out outBlock { + float gid5; + vec4 gid6; +} myblk[]; + +void main() +{ + uint iid = gl_LocalInvocationID.x; + + myblk[iid].gid5 = mytask.gid1[1] + mybuf.gid3[1]; + myblk[iid].gid6 = mytask.gid2 + mybuf.gid4; +} diff --git a/Test/spv.meshShaderUserDefined.mesh b/Test/spv.meshShaderUserDefined.mesh new file mode 100644 index 000000000..8b0937dbc --- /dev/null +++ b/Test/spv.meshShaderUserDefined.mesh @@ -0,0 +1,59 @@ +#version 450 + +#define MAX_VER 81 +#define MAX_PRIM 32 + +#define BARRIER() \ + memoryBarrierShared(); \ + barrier(); + +#extension GL_NV_mesh_shader : enable + +layout(local_size_x = 32) in; + +layout(max_vertices=MAX_VER) out; +layout(max_primitives=MAX_PRIM) out; +layout(triangles) out; + +// test use of user defined interface out blocks: + +// per-primitive block +perprimitiveNV layout(location=0) out myblock { + float f; + float fArr[4]; + vec3 pos; + vec4 posArr[4]; + mat4 m; + mat3 mArr[2]; +} blk[]; + +// per-vertex block +layout(location=20) out myblock2 { + float f; + vec4 pos; + mat4 m; +} blk2[]; + +void main() +{ + uint iid = gl_LocalInvocationID.x; + uint gid = gl_WorkGroupID.x; + + blk[iid].f = 11.0; + blk[iid+1].fArr[gid] = blk[iid].f; + blk[iid/2].pos.yzx = vec3(14.0, 15.0, 13.0); + blk[iid*2].posArr[1].yzw = blk[iid/2].pos; + blk[iid/4].m[2].wzyx = vec4(13.0, 14.0, 15.0, 16.0); + blk[iid].mArr[0][1][1] = blk[iid/4].m[2].w; + blk[iid*4].mArr[1][gid] = vec3(17.0, 18.0, 19.0); + + BARRIER(); + + blk2[iid].f = blk2[iid-1].f + 20.0; + blk2[iid].pos = vec4(21.0, 22.0, 23.0, 24.0); + blk2[iid+1].m[gid] = blk2[iid].pos; + blk2[iid+1].m[gid][2] = 29.0; + blk2[iid+2].m[3] = blk2[iid+1].m[gid]; + + BARRIER(); +} diff --git a/Test/spv.meshTaskShader.task b/Test/spv.meshTaskShader.task new file mode 100644 index 000000000..c12b3bdd1 --- /dev/null +++ b/Test/spv.meshTaskShader.task @@ -0,0 +1,49 @@ +#version 450 + +#define BARRIER() \ + memoryBarrierShared(); \ + barrier(); + +#extension GL_NV_mesh_shader : enable + +layout(local_size_x = 32) in; + +// test use of shared memory in task shaders: +layout(binding=0) writeonly uniform image2D uni_image; +uniform block0 { + uint uni_value; +}; +shared vec4 mem[10]; + +// test use of task memory in task shaders: +taskNV out Task { + vec2 dummy; + vec2 submesh[3]; +} mytask; + +void main() +{ + uint iid = gl_LocalInvocationID.x; + uint gid = gl_WorkGroupID.x; + + // 1. shared memory load and stores + for (uint i = 0; i < 10; ++i) { + mem[i] = vec4(i + uni_value); + } + imageStore(uni_image, ivec2(iid), mem[gid]); + imageStore(uni_image, ivec2(iid), mem[gid+1]); + + BARRIER(); + + // 2. task memory stores + + mytask.dummy = vec2(30.0, 31.0); + mytask.submesh[0] = vec2(32.0, 33.0); + mytask.submesh[1] = vec2(34.0, 35.0); + mytask.submesh[2] = mytask.submesh[gid%2]; + + BARRIER(); + + // 3. set task count + gl_TaskCountNV = 3; +} diff --git a/glslang/Include/BaseTypes.h b/glslang/Include/BaseTypes.h index 5e433fd9b..5a191aad7 100644 --- a/glslang/Include/BaseTypes.h +++ b/glslang/Include/BaseTypes.h @@ -229,6 +229,14 @@ enum TBuiltInVariable { EbvFragFullyCoveredNV, EbvBaryCoordNV, EbvBaryCoordNoPerspNV, + EbvTaskCountNV, + EbvPrimitiveCountNV, + EbvPrimitiveIndicesNV, + EbvClipDistancePerViewNV, + EbvCullDistancePerViewNV, + EbvLayerPerViewNV, + EbvMeshViewCountNV, + EbvMeshViewIndicesNV, #endif // HLSL built-ins that live only temporarily, until they get remapped @@ -369,6 +377,14 @@ __inline const char* GetBuiltInVariableString(TBuiltInVariable v) case EbvFragFullyCoveredNV: return "FragFullyCoveredNV"; case EbvBaryCoordNV: return "BaryCoordNV"; case EbvBaryCoordNoPerspNV: return "BaryCoordNoPerspNV"; + case EbvTaskCountNV: return "TaskCountNV"; + case EbvPrimitiveCountNV: return "PrimitiveCountNV"; + case EbvPrimitiveIndicesNV: return "PrimitiveIndicesNV"; + case EbvClipDistancePerViewNV: return "ClipDistancePerViewNV"; + case EbvCullDistancePerViewNV: return "CullDistancePerViewNV"; + case EbvLayerPerViewNV: return "LayerPerViewNV"; + case EbvMeshViewCountNV: return "MeshViewCountNV"; + case EbvMeshViewIndicesNV: return "MeshViewIndicesNV"; #endif default: return "unknown built-in variable"; } diff --git a/glslang/Include/ResourceLimits.h b/glslang/Include/ResourceLimits.h index 0d07b8c84..89163ac76 100644 --- a/glslang/Include/ResourceLimits.h +++ b/glslang/Include/ResourceLimits.h @@ -133,6 +133,17 @@ struct TBuiltInResource { int maxCullDistances; int maxCombinedClipAndCullDistances; int maxSamples; +#ifdef NV_EXTENSIONS + int maxMeshOutputVerticesNV; + int maxMeshOutputPrimitivesNV; + int maxMeshWorkGroupSizeX_NV; + int maxMeshWorkGroupSizeY_NV; + int maxMeshWorkGroupSizeZ_NV; + int maxTaskWorkGroupSizeX_NV; + int maxTaskWorkGroupSizeY_NV; + int maxTaskWorkGroupSizeZ_NV; + int maxMeshViewCountNV; +#endif TLimits limits; }; diff --git a/glslang/Include/Types.h b/glslang/Include/Types.h index 0e7d354c6..43fc7c664 100644 --- a/glslang/Include/Types.h +++ b/glslang/Include/Types.h @@ -459,6 +459,9 @@ public: #endif #ifdef NV_EXTENSIONS pervertexNV = false; + perPrimitiveNV = false; + perViewNV = false; + perTaskNV = false; #endif } @@ -506,6 +509,9 @@ public: #endif #ifdef NV_EXTENSIONS bool pervertexNV : 1; + bool perPrimitiveNV : 1; + bool perViewNV : 1; + bool perTaskNV : 1; #endif bool patch : 1; bool sample : 1; @@ -620,6 +626,33 @@ public: } } + bool isPerPrimitive() const + { +#ifdef NV_EXTENSIONS + return perPrimitiveNV; +#else + return false; +#endif + } + + bool isPerView() const + { +#ifdef NV_EXTENSIONS + return perViewNV; +#else + return false; +#endif + } + + bool isTaskMemory() const + { +#ifdef NV_EXTENSIONS + return perTaskNV; +#else + return false; +#endif + } + bool isIo() const { switch (storage) { @@ -672,6 +705,8 @@ public: #ifdef NV_EXTENSIONS case EShLangFragment: return pervertexNV && isPipeInput(); + case EShLangMeshNV: + return ! perTaskNV && isPipeOutput(); #endif default: @@ -1053,7 +1088,7 @@ struct TShaderQualifiers { bool pixelCenterInteger; // fragment shader bool originUpperLeft; // fragment shader int invocations; - int vertices; // both for tessellation "vertices" and geometry "max_vertices" + int vertices; // for tessellation "vertices", geometry & mesh "max_vertices" TVertexSpacing spacing; TVertexOrder order; bool pointMode; @@ -1069,6 +1104,7 @@ struct TShaderQualifiers { bool layoutOverrideCoverage; // true if layout override_coverage set bool layoutDerivativeGroupQuads; // true if layout derivative_group_quadsNV set bool layoutDerivativeGroupLinear; // true if layout derivative_group_linearNV set + int primitives; // mesh shader "max_primitives"DerivativeGroupLinear; // true if layout derivative_group_linearNV set #endif void init() @@ -1093,10 +1129,10 @@ struct TShaderQualifiers { blendEquation = false; numViews = TQualifier::layoutNotSet; #ifdef NV_EXTENSIONS - layoutOverrideCoverage = false; - layoutDerivativeGroupQuads = false; + layoutOverrideCoverage = false; + layoutDerivativeGroupQuads = false; layoutDerivativeGroupLinear = false; - + primitives = TQualifier::layoutNotSet; #endif } @@ -1145,6 +1181,8 @@ struct TShaderQualifiers { layoutDerivativeGroupQuads = src.layoutDerivativeGroupQuads; if (src.layoutDerivativeGroupLinear) layoutDerivativeGroupLinear = src.layoutDerivativeGroupLinear; + if (src.primitives != TQualifier::layoutNotSet) + primitives = src.primitives; #endif } }; @@ -1751,6 +1789,12 @@ public: #ifdef NV_EXTENSIONS if (qualifier.pervertexNV) appendStr(" pervertexNV"); + if (qualifier.perPrimitiveNV) + appendStr(" perprimitiveNV"); + if (qualifier.perViewNV) + appendStr(" perviewNV"); + if (qualifier.perTaskNV) + appendStr(" taskNV"); #endif if (qualifier.patch) appendStr(" patch"); diff --git a/glslang/Include/intermediate.h b/glslang/Include/intermediate.h index 5fa75d97e..9f51f7db6 100644 --- a/glslang/Include/intermediate.h +++ b/glslang/Include/intermediate.h @@ -893,6 +893,9 @@ enum TOperator { EOpFindLSB, EOpFindMSB, +#ifdef NV_EXTENSIONS + EOpWritePackedPrimitiveIndices4x8NV, +#endif // // HLSL operations // diff --git a/glslang/MachineIndependent/Initialize.cpp b/glslang/MachineIndependent/Initialize.cpp index 68618a934..782b3259e 100644 --- a/glslang/MachineIndependent/Initialize.cpp +++ b/glslang/MachineIndependent/Initialize.cpp @@ -2941,6 +2941,16 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV "\n" ); +#ifdef NV_EXTENSIONS + stageBuiltins[EShLangMeshNV].append( + "void subgroupMemoryBarrierShared();" + "\n" + ); + stageBuiltins[EShLangTaskNV].append( + "void subgroupMemoryBarrierShared();" + "\n" + ); +#endif } if (profile != EEsProfile && version >= 460) { @@ -4867,6 +4877,16 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV stageBuiltins[EShLangCompute].append( "void barrier();" ); +#ifdef NV_EXTENSIONS + if ((profile != EEsProfile && version >= 450) || esBarrier) { + stageBuiltins[EShLangMeshNV].append( + "void barrier();" + ); + stageBuiltins[EShLangTaskNV].append( + "void barrier();" + ); + } +#endif if ((profile != EEsProfile && version >= 130) || esBarrier) commonBuiltins.append( "void memoryBarrier();" @@ -4882,6 +4902,18 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV "void groupMemoryBarrier();" ); } +#ifdef NV_EXTENSIONS + if (profile != EEsProfile && version >= 450) { + stageBuiltins[EShLangMeshNV].append( + "void memoryBarrierShared();" + "void groupMemoryBarrier();" + ); + stageBuiltins[EShLangTaskNV].append( + "void memoryBarrierShared();" + "void groupMemoryBarrier();" + ); + } +#endif commonBuiltins.append("void controlBarrier(int, int, int, int);\n" "void memoryBarrier(int, int, int);\n"); @@ -5039,6 +5071,13 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV stageBuiltins[EShLangCompute].append(derivativesAndControl64bits); stageBuiltins[EShLangCompute].append("\n"); } + + // Builtins for GL_NV_mesh_shader + if (profile != EEsProfile && version >= 450) { + stageBuiltins[EShLangMeshNV].append( + "void writePackedPrimitiveIndices4x8NV(uint, uint);" + "\n"); + } #endif //============================================================================ @@ -5220,6 +5259,89 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV "\n"); } +#ifdef NV_EXTENSIONS + //============================================================================ + // + // Define the interface to the mesh/task shader. + // + //============================================================================ + + if (profile != EEsProfile && version >= 450) { + // per-vertex attributes + stageBuiltins[EShLangMeshNV].append( + "out gl_MeshPerVertexNV {" + "vec4 gl_Position;" + "float gl_PointSize;" + "float gl_ClipDistance[];" + "float gl_CullDistance[];" + "perviewNV vec4 gl_PositionPerViewNV[];" + "perviewNV float gl_ClipDistancePerViewNV[][8];" + "perviewNV float gl_CullDistancePerViewNV[][8];" + "} gl_MeshVerticesNV[];" + ); + + // per-primitive attributes + stageBuiltins[EShLangMeshNV].append( + "perprimitiveNV out gl_MeshPerPrimitiveNV {" + "int gl_PrimitiveID;" + "int gl_Layer;" + "int gl_ViewportIndex;" + "int gl_ViewportMask[];" + "perviewNV int gl_LayerPerViewNV[];" + "perviewNV int gl_ViewportMaskPerViewNV[][1];" + "} gl_MeshPrimitivesNV[];" + ); + + stageBuiltins[EShLangMeshNV].append( + "out uint gl_PrimitiveCountNV;" + "out uint gl_PrimitiveIndicesNV[];" + + "in uint gl_MeshViewCountNV;" + "in uint gl_MeshViewIndicesNV[4];" + + "const highp uvec3 gl_WorkGroupSize = uvec3(1,1,1);" + + "in highp uvec3 gl_WorkGroupID;" + "in highp uvec3 gl_LocalInvocationID;" + + "in highp uvec3 gl_GlobalInvocationID;" + "in highp uint gl_LocalInvocationIndex;" + + "in highp int gl_DeviceIndex;" // GL_EXT_device_group + "in int gl_DrawIDARB;" // GL_ARB_shader_draw_parameters + + "\n"); + + if (version >= 460) { + stageBuiltins[EShLangMeshNV].append( + "in int gl_DrawID;" + ); + } + + stageBuiltins[EShLangTaskNV].append( + "out uint gl_TaskCountNV;" + + "const highp uvec3 gl_WorkGroupSize = uvec3(1,1,1);" + + "in highp uvec3 gl_WorkGroupID;" + "in highp uvec3 gl_LocalInvocationID;" + + "in highp uvec3 gl_GlobalInvocationID;" + "in highp uint gl_LocalInvocationIndex;" + + "in highp int gl_DeviceIndex;" // GL_EXT_device_group + "in int gl_DrawIDARB;" // GL_ARB_shader_draw_parameters + + "\n"); + + if (version >= 460) { + stageBuiltins[EShLangTaskNV].append( + "in int gl_DrawID;" + ); + } + } +#endif + //============================================================================ // // Define the interface to the vertex shader. @@ -5889,6 +6011,10 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV stageBuiltins[EShLangGeometry] .append(ballotDecls); stageBuiltins[EShLangCompute] .append(ballotDecls); stageBuiltins[EShLangFragment] .append(fragmentBallotDecls); +#ifdef NV_EXTENSIONS + stageBuiltins[EShLangMeshNV] .append(ballotDecls); + stageBuiltins[EShLangTaskNV] .append(ballotDecls); +#endif } if ((profile != EEsProfile && version >= 140) || @@ -5925,11 +6051,25 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV stageBuiltins[EShLangGeometry] .append(ballotDecls); stageBuiltins[EShLangCompute] .append(ballotDecls); stageBuiltins[EShLangFragment] .append(fragmentBallotDecls); +#ifdef NV_EXTENSIONS + stageBuiltins[EShLangMeshNV] .append(ballotDecls); + stageBuiltins[EShLangTaskNV] .append(ballotDecls); +#endif stageBuiltins[EShLangCompute].append( "highp in uint gl_NumSubgroups;" "highp in uint gl_SubgroupID;" "\n"); +#ifdef NV_EXTENSIONS + stageBuiltins[EShLangMeshNV].append( + "highp in uint gl_NumSubgroups;" + "highp in uint gl_SubgroupID;" + "\n"); + stageBuiltins[EShLangTaskNV].append( + "highp in uint gl_NumSubgroups;" + "highp in uint gl_SubgroupID;" + "\n"); +#endif } if (version >= 300 /* both ES and non-ES */) { @@ -7398,6 +7538,31 @@ void TBuiltIns::initialize(const TBuiltInResource &resources, int version, EProf } #endif +#ifdef NV_EXTENSIONS + // SPV_NV_mesh_shader + if (profile != EEsProfile && version >= 450) { + snprintf(builtInConstant, maxSize, "const int gl_MaxMeshOutputVerticesNV = %d;", resources.maxMeshOutputVerticesNV); + s.append(builtInConstant); + + snprintf(builtInConstant, maxSize, "const int gl_MaxMeshOutputPrimitivesNV = %d;", resources.maxMeshOutputPrimitivesNV); + s.append(builtInConstant); + + snprintf(builtInConstant, maxSize, "const ivec3 gl_MaxMeshWorkGroupSizeNV = ivec3(%d,%d,%d);", resources.maxMeshWorkGroupSizeX_NV, + resources.maxMeshWorkGroupSizeY_NV, + resources.maxMeshWorkGroupSizeZ_NV); + s.append(builtInConstant); + snprintf(builtInConstant, maxSize, "const ivec3 gl_MaxTaskWorkGroupSizeNV = ivec3(%d,%d,%d);", resources.maxTaskWorkGroupSizeX_NV, + resources.maxTaskWorkGroupSizeY_NV, + resources.maxTaskWorkGroupSizeZ_NV); + s.append(builtInConstant); + + snprintf(builtInConstant, maxSize, "const int gl_MaxMeshViewCountNV = %d;", resources.maxMeshViewCountNV); + s.append(builtInConstant); + + s.append("\n"); + } +#endif + s.append("\n"); } @@ -8265,7 +8430,7 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion BuiltInVariable("gl_SubGroupSizeARB", EbvSubGroupSize, symbolTable); } - // GL_ARB_shader_ballot + // GL_KHR_shader_subgroup if (spvVersion.vulkan > 0) { symbolTable.setVariableExtensions("gl_SubgroupSize", 1, &E_GL_KHR_shader_subgroup_basic); symbolTable.setVariableExtensions("gl_SubgroupInvocationID", 1, &E_GL_KHR_shader_subgroup_basic); @@ -8304,6 +8469,200 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion } break; +#ifdef NV_EXTENSIONS + case EShLangMeshNV: + if (profile != EEsProfile && version >= 450) { + // Per-vertex builtins + BuiltInVariable("gl_MeshVerticesNV", "gl_Position", EbvPosition, symbolTable); + BuiltInVariable("gl_MeshVerticesNV", "gl_PointSize", EbvPointSize, symbolTable); + BuiltInVariable("gl_MeshVerticesNV", "gl_ClipDistance", EbvClipDistance, symbolTable); + BuiltInVariable("gl_MeshVerticesNV", "gl_CullDistance", EbvCullDistance, symbolTable); + // Per-view builtins + BuiltInVariable("gl_MeshVerticesNV", "gl_PositionPerViewNV", EbvPositionPerViewNV, symbolTable); + BuiltInVariable("gl_MeshVerticesNV", "gl_ClipDistancePerViewNV", EbvClipDistancePerViewNV, symbolTable); + BuiltInVariable("gl_MeshVerticesNV", "gl_CullDistancePerViewNV", EbvCullDistancePerViewNV, symbolTable); + + // Per-primitive builtins + BuiltInVariable("gl_MeshPrimitivesNV", "gl_PrimitiveID", EbvPrimitiveId, symbolTable); + BuiltInVariable("gl_MeshPrimitivesNV", "gl_Layer", EbvLayer, symbolTable); + BuiltInVariable("gl_MeshPrimitivesNV", "gl_ViewportIndex", EbvViewportIndex, symbolTable); + BuiltInVariable("gl_MeshPrimitivesNV", "gl_ViewportMask", EbvViewportMaskNV, symbolTable); + // Per-view builtins + BuiltInVariable("gl_MeshPrimitivesNV", "gl_LayerPerViewNV", EbvLayerPerViewNV, symbolTable); + BuiltInVariable("gl_MeshPrimitivesNV", "gl_ViewportMaskPerViewNV", EbvViewportMaskPerViewNV, symbolTable); + + symbolTable.setVariableExtensions("gl_PrimitiveCountNV", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_PrimitiveIndicesNV", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_MeshViewCountNV", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_MeshViewIndicesNV", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_WorkGroupSize", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_WorkGroupID", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_LocalInvocationID", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_GlobalInvocationID", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_LocalInvocationIndex", 1, &E_GL_NV_mesh_shader); + + BuiltInVariable("gl_PrimitiveCountNV", EbvPrimitiveCountNV, symbolTable); + BuiltInVariable("gl_PrimitiveIndicesNV", EbvPrimitiveIndicesNV, symbolTable); + BuiltInVariable("gl_MeshViewCountNV", EbvMeshViewCountNV, symbolTable); + BuiltInVariable("gl_MeshViewIndicesNV", EbvMeshViewIndicesNV, symbolTable); + BuiltInVariable("gl_WorkGroupSize", EbvWorkGroupSize, symbolTable); + BuiltInVariable("gl_WorkGroupID", EbvWorkGroupId, symbolTable); + BuiltInVariable("gl_LocalInvocationID", EbvLocalInvocationId, symbolTable); + BuiltInVariable("gl_GlobalInvocationID", EbvGlobalInvocationId, symbolTable); + BuiltInVariable("gl_LocalInvocationIndex", EbvLocalInvocationIndex, symbolTable); + + symbolTable.setVariableExtensions("gl_MaxMeshOutputVerticesNV", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_MaxMeshOutputPrimitivesNV", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_MaxMeshWorkGroupSizeNV", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_MaxMeshViewCountNV", 1, &E_GL_NV_mesh_shader); + + symbolTable.setFunctionExtensions("barrier", 1, &E_GL_NV_mesh_shader); + symbolTable.setFunctionExtensions("memoryBarrierShared", 1, &E_GL_NV_mesh_shader); + symbolTable.setFunctionExtensions("groupMemoryBarrier", 1, &E_GL_NV_mesh_shader); + + // GL_EXT_device_group + symbolTable.setVariableExtensions("gl_DeviceIndex", 1, &E_GL_EXT_device_group); + BuiltInVariable("gl_DeviceIndex", EbvDeviceIndex, symbolTable); + + // GL_ARB_shader_draw_parameters + symbolTable.setVariableExtensions("gl_DrawIDARB", 1, &E_GL_ARB_shader_draw_parameters); + BuiltInVariable("gl_DrawIDARB", EbvDrawId, symbolTable); + if (version >= 460) { + BuiltInVariable("gl_DrawID", EbvDrawId, symbolTable); + } + + // GL_ARB_shader_ballot + symbolTable.setVariableExtensions("gl_SubGroupSizeARB", 1, &E_GL_ARB_shader_ballot); + symbolTable.setVariableExtensions("gl_SubGroupInvocationARB", 1, &E_GL_ARB_shader_ballot); + symbolTable.setVariableExtensions("gl_SubGroupEqMaskARB", 1, &E_GL_ARB_shader_ballot); + symbolTable.setVariableExtensions("gl_SubGroupGeMaskARB", 1, &E_GL_ARB_shader_ballot); + symbolTable.setVariableExtensions("gl_SubGroupGtMaskARB", 1, &E_GL_ARB_shader_ballot); + symbolTable.setVariableExtensions("gl_SubGroupLeMaskARB", 1, &E_GL_ARB_shader_ballot); + symbolTable.setVariableExtensions("gl_SubGroupLtMaskARB", 1, &E_GL_ARB_shader_ballot); + + BuiltInVariable("gl_SubGroupInvocationARB", EbvSubGroupInvocation, symbolTable); + BuiltInVariable("gl_SubGroupEqMaskARB", EbvSubGroupEqMask, symbolTable); + BuiltInVariable("gl_SubGroupGeMaskARB", EbvSubGroupGeMask, symbolTable); + BuiltInVariable("gl_SubGroupGtMaskARB", EbvSubGroupGtMask, symbolTable); + BuiltInVariable("gl_SubGroupLeMaskARB", EbvSubGroupLeMask, symbolTable); + BuiltInVariable("gl_SubGroupLtMaskARB", EbvSubGroupLtMask, symbolTable); + + if (spvVersion.vulkan > 0) + // Treat "gl_SubGroupSizeARB" as shader input instead of uniform for Vulkan + SpecialQualifier("gl_SubGroupSizeARB", EvqVaryingIn, EbvSubGroupSize, symbolTable); + else + BuiltInVariable("gl_SubGroupSizeARB", EbvSubGroupSize, symbolTable); + } + + // GL_KHR_shader_subgroup + if (spvVersion.vulkan > 0) { + symbolTable.setVariableExtensions("gl_NumSubgroups", 1, &E_GL_KHR_shader_subgroup_basic); + symbolTable.setVariableExtensions("gl_SubgroupID", 1, &E_GL_KHR_shader_subgroup_basic); + symbolTable.setVariableExtensions("gl_SubgroupSize", 1, &E_GL_KHR_shader_subgroup_basic); + symbolTable.setVariableExtensions("gl_SubgroupInvocationID", 1, &E_GL_KHR_shader_subgroup_basic); + symbolTable.setVariableExtensions("gl_SubgroupEqMask", 1, &E_GL_KHR_shader_subgroup_ballot); + symbolTable.setVariableExtensions("gl_SubgroupGeMask", 1, &E_GL_KHR_shader_subgroup_ballot); + symbolTable.setVariableExtensions("gl_SubgroupGtMask", 1, &E_GL_KHR_shader_subgroup_ballot); + symbolTable.setVariableExtensions("gl_SubgroupLeMask", 1, &E_GL_KHR_shader_subgroup_ballot); + symbolTable.setVariableExtensions("gl_SubgroupLtMask", 1, &E_GL_KHR_shader_subgroup_ballot); + + BuiltInVariable("gl_NumSubgroups", EbvNumSubgroups, symbolTable); + BuiltInVariable("gl_SubgroupID", EbvSubgroupID, symbolTable); + BuiltInVariable("gl_SubgroupSize", EbvSubgroupSize2, symbolTable); + BuiltInVariable("gl_SubgroupInvocationID", EbvSubgroupInvocation2, symbolTable); + BuiltInVariable("gl_SubgroupEqMask", EbvSubgroupEqMask2, symbolTable); + BuiltInVariable("gl_SubgroupGeMask", EbvSubgroupGeMask2, symbolTable); + BuiltInVariable("gl_SubgroupGtMask", EbvSubgroupGtMask2, symbolTable); + BuiltInVariable("gl_SubgroupLeMask", EbvSubgroupLeMask2, symbolTable); + BuiltInVariable("gl_SubgroupLtMask", EbvSubgroupLtMask2, symbolTable); + + symbolTable.setFunctionExtensions("subgroupMemoryBarrierShared", 1, &E_GL_KHR_shader_subgroup_basic); + } + break; + + case EShLangTaskNV: + if (profile != EEsProfile && version >= 450) { + symbolTable.setVariableExtensions("gl_TaskCountNV", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_WorkGroupSize", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_WorkGroupID", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_LocalInvocationID", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_GlobalInvocationID", 1, &E_GL_NV_mesh_shader); + symbolTable.setVariableExtensions("gl_LocalInvocationIndex", 1, &E_GL_NV_mesh_shader); + + BuiltInVariable("gl_TaskCountNV", EbvTaskCountNV, symbolTable); + BuiltInVariable("gl_WorkGroupSize", EbvWorkGroupSize, symbolTable); + BuiltInVariable("gl_WorkGroupID", EbvWorkGroupId, symbolTable); + BuiltInVariable("gl_LocalInvocationID", EbvLocalInvocationId, symbolTable); + BuiltInVariable("gl_GlobalInvocationID", EbvGlobalInvocationId, symbolTable); + BuiltInVariable("gl_LocalInvocationIndex", EbvLocalInvocationIndex, symbolTable); + + symbolTable.setVariableExtensions("gl_MaxTaskWorkGroupSizeNV", 1, &E_GL_NV_mesh_shader); + + symbolTable.setFunctionExtensions("barrier", 1, &E_GL_NV_mesh_shader); + symbolTable.setFunctionExtensions("memoryBarrierShared", 1, &E_GL_NV_mesh_shader); + symbolTable.setFunctionExtensions("groupMemoryBarrier", 1, &E_GL_NV_mesh_shader); + + // GL_EXT_device_group + symbolTable.setVariableExtensions("gl_DeviceIndex", 1, &E_GL_EXT_device_group); + BuiltInVariable("gl_DeviceIndex", EbvDeviceIndex, symbolTable); + + // GL_ARB_shader_draw_parameters + symbolTable.setVariableExtensions("gl_DrawIDARB", 1, &E_GL_ARB_shader_draw_parameters); + BuiltInVariable("gl_DrawIDARB", EbvDrawId, symbolTable); + if (version >= 460) { + BuiltInVariable("gl_DrawID", EbvDrawId, symbolTable); + } + + // GL_ARB_shader_ballot + symbolTable.setVariableExtensions("gl_SubGroupSizeARB", 1, &E_GL_ARB_shader_ballot); + symbolTable.setVariableExtensions("gl_SubGroupInvocationARB", 1, &E_GL_ARB_shader_ballot); + symbolTable.setVariableExtensions("gl_SubGroupEqMaskARB", 1, &E_GL_ARB_shader_ballot); + symbolTable.setVariableExtensions("gl_SubGroupGeMaskARB", 1, &E_GL_ARB_shader_ballot); + symbolTable.setVariableExtensions("gl_SubGroupGtMaskARB", 1, &E_GL_ARB_shader_ballot); + symbolTable.setVariableExtensions("gl_SubGroupLeMaskARB", 1, &E_GL_ARB_shader_ballot); + symbolTable.setVariableExtensions("gl_SubGroupLtMaskARB", 1, &E_GL_ARB_shader_ballot); + + BuiltInVariable("gl_SubGroupInvocationARB", EbvSubGroupInvocation, symbolTable); + BuiltInVariable("gl_SubGroupEqMaskARB", EbvSubGroupEqMask, symbolTable); + BuiltInVariable("gl_SubGroupGeMaskARB", EbvSubGroupGeMask, symbolTable); + BuiltInVariable("gl_SubGroupGtMaskARB", EbvSubGroupGtMask, symbolTable); + BuiltInVariable("gl_SubGroupLeMaskARB", EbvSubGroupLeMask, symbolTable); + BuiltInVariable("gl_SubGroupLtMaskARB", EbvSubGroupLtMask, symbolTable); + + if (spvVersion.vulkan > 0) + // Treat "gl_SubGroupSizeARB" as shader input instead of uniform for Vulkan + SpecialQualifier("gl_SubGroupSizeARB", EvqVaryingIn, EbvSubGroupSize, symbolTable); + else + BuiltInVariable("gl_SubGroupSizeARB", EbvSubGroupSize, symbolTable); + } + + // GL_KHR_shader_subgroup + if (spvVersion.vulkan > 0) { + symbolTable.setVariableExtensions("gl_NumSubgroups", 1, &E_GL_KHR_shader_subgroup_basic); + symbolTable.setVariableExtensions("gl_SubgroupID", 1, &E_GL_KHR_shader_subgroup_basic); + symbolTable.setVariableExtensions("gl_SubgroupSize", 1, &E_GL_KHR_shader_subgroup_basic); + symbolTable.setVariableExtensions("gl_SubgroupInvocationID", 1, &E_GL_KHR_shader_subgroup_basic); + symbolTable.setVariableExtensions("gl_SubgroupEqMask", 1, &E_GL_KHR_shader_subgroup_ballot); + symbolTable.setVariableExtensions("gl_SubgroupGeMask", 1, &E_GL_KHR_shader_subgroup_ballot); + symbolTable.setVariableExtensions("gl_SubgroupGtMask", 1, &E_GL_KHR_shader_subgroup_ballot); + symbolTable.setVariableExtensions("gl_SubgroupLeMask", 1, &E_GL_KHR_shader_subgroup_ballot); + symbolTable.setVariableExtensions("gl_SubgroupLtMask", 1, &E_GL_KHR_shader_subgroup_ballot); + + BuiltInVariable("gl_NumSubgroups", EbvNumSubgroups, symbolTable); + BuiltInVariable("gl_SubgroupID", EbvSubgroupID, symbolTable); + BuiltInVariable("gl_SubgroupSize", EbvSubgroupSize2, symbolTable); + BuiltInVariable("gl_SubgroupInvocationID", EbvSubgroupInvocation2, symbolTable); + BuiltInVariable("gl_SubgroupEqMask", EbvSubgroupEqMask2, symbolTable); + BuiltInVariable("gl_SubgroupGeMask", EbvSubgroupGeMask2, symbolTable); + BuiltInVariable("gl_SubgroupGtMask", EbvSubgroupGtMask2, symbolTable); + BuiltInVariable("gl_SubgroupLeMask", EbvSubgroupLeMask2, symbolTable); + BuiltInVariable("gl_SubgroupLtMask", EbvSubgroupLtMask2, symbolTable); + + symbolTable.setFunctionExtensions("subgroupMemoryBarrierShared", 1, &E_GL_KHR_shader_subgroup_basic); + } + break; +#endif + default: assert(false && "Language not supported"); break; @@ -8840,6 +9199,20 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion #endif break; +#ifdef NV_EXTENSIONS + case EShLangMeshNV: + if (profile != EEsProfile && version >= 450) { + symbolTable.relateToOperator("writePackedPrimitiveIndices4x8NV", EOpWritePackedPrimitiveIndices4x8NV); + } + // fall through + case EShLangTaskNV: + if (profile != EEsProfile && version >= 450) { + symbolTable.relateToOperator("memoryBarrierShared", EOpMemoryBarrierShared); + symbolTable.relateToOperator("groupMemoryBarrier", EOpGroupMemoryBarrier); + } + break; +#endif + default: assert(false && "Language not supported"); } diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp index 3bcf537c5..297956c09 100644 --- a/glslang/MachineIndependent/ParseHelper.cpp +++ b/glslang/MachineIndependent/ParseHelper.cpp @@ -491,7 +491,8 @@ void TParseContext::makeEditable(TSymbol*& symbol) ioArraySymbolResizeList.push_back(symbol); } -// Return true if this is a geometry shader input array or tessellation control output array. +// Return true if this is a geometry shader input array or tessellation control output array +// or mesh shader output array. bool TParseContext::isIoResizeArray(const TType& type) const { return type.isArray() && @@ -499,7 +500,9 @@ bool TParseContext::isIoResizeArray(const TType& type) const (language == EShLangTessControl && type.getQualifier().storage == EvqVaryingOut && ! type.getQualifier().patch) #ifdef NV_EXTENSIONS || - (language == EShLangFragment && type.getQualifier().storage == EvqVaryingIn && type.getQualifier().pervertexNV) + (language == EShLangFragment && type.getQualifier().storage == EvqVaryingIn && type.getQualifier().pervertexNV) || + (language == EShLangMeshNV && type.getQualifier().storage == EvqVaryingOut && !type.getQualifier().perTaskNV) + #endif ); } @@ -551,7 +554,7 @@ void TParseContext::handleIoResizeArrayAccess(const TSourceLoc& /*loc*/, TInterm // fix array size, if it can be fixed and needs to be fixed (will allow variable indexing) if (symbolNode->getType().isUnsizedArray()) { - int newSize = getIoArrayImplicitSize(); + int newSize = getIoArrayImplicitSize(symbolNode->getType().getQualifier().isPerPrimitive()); if (newSize > 0) symbolNode->getWritableType().changeOuterArraySize(newSize); } @@ -565,9 +568,9 @@ void TParseContext::handleIoResizeArrayAccess(const TSourceLoc& /*loc*/, TInterm // Types without an array size will be given one. // Types already having a size that is wrong will get an error. // -void TParseContext::checkIoArraysConsistency(const TSourceLoc& loc, bool tailOnly) +void TParseContext::checkIoArraysConsistency(const TSourceLoc& loc, bool tailOnly, bool isPerPrimitive) { - int requiredSize = getIoArrayImplicitSize(); + int requiredSize = getIoArrayImplicitSize(isPerPrimitive); if (requiredSize == 0) return; @@ -581,6 +584,11 @@ void TParseContext::checkIoArraysConsistency(const TSourceLoc& loc, bool tailOnl ) feature = "vertices"; +#ifdef NV_EXTENSIONS + else if (language == EShLangMeshNV) { + feature = isPerPrimitive ? "max_primitives" : "max_vertices"; + } +#endif else feature = "unknown"; @@ -593,7 +601,7 @@ void TParseContext::checkIoArraysConsistency(const TSourceLoc& loc, bool tailOnl checkIoArrayConsistency(loc, requiredSize, feature, ioArraySymbolResizeList[i]->getWritableType(), ioArraySymbolResizeList[i]->getName()); } -int TParseContext::getIoArrayImplicitSize() const +int TParseContext::getIoArrayImplicitSize(bool isPerPrimitive) const { if (language == EShLangGeometry) return TQualifier::mapGeometryToSize(intermediate.getInputPrimitive()); @@ -602,6 +610,13 @@ int TParseContext::getIoArrayImplicitSize() const #ifdef NV_EXTENSIONS else if (language == EShLangFragment) return 3; //Number of vertices for Fragment shader is always three. + else if (language == EShLangMeshNV) { + if (isPerPrimitive) { + return intermediate.getPrimitives() != TQualifier::layoutNotSet ? intermediate.getPrimitives() : 0; + } else { + return intermediate.getVertices() != TQualifier::layoutNotSet ? intermediate.getVertices() : 0; + } + } #endif else @@ -622,6 +637,8 @@ void TParseContext::checkIoArrayConsistency(const TSourceLoc& loc, int requiredS if (type.getOuterArraySize() > requiredSize) error(loc, " cannot be greater than 3 for pervertexNV", feature, name.c_str()); } + else if (language == EShLangMeshNV) + error(loc, "inconsistent output array size of", feature, name.c_str()); #endif else assert(0); @@ -1322,8 +1339,15 @@ TIntermTyped* TParseContext::handleLengthMethod(const TSourceLoc& loc, TFunction // without actually redeclaring the array. (It is an error to use a member before the // redeclaration, but not an error to use the array name itself.) const TString& name = intermNode->getAsSymbolNode()->getName(); - if (name == "gl_in" || name == "gl_out") - length = getIoArrayImplicitSize(); + if (name == "gl_in" || name == "gl_out" +#ifdef NV_EXTENSIONS + || name == "gl_MeshVerticesNV" + || name == "gl_MeshPrimitivesNV" +#endif + ) + { + length = getIoArrayImplicitSize(type.getQualifier().isPerPrimitive()); + } } if (length == 0) { if (intermNode->getAsSymbolNode() && isIoResizeArray(type)) @@ -3070,6 +3094,11 @@ void TParseContext::globalQualifierTypeCheck(const TSourceLoc& loc, const TQuali if (qualifier.patch && qualifier.isInterpolation()) error(loc, "cannot use interpolation qualifiers with patch", "patch", ""); +#ifdef NV_EXTENSIONS + if (qualifier.perTaskNV && publicType.basicType != EbtBlock) + error(loc, "taskNV variables can be declared only as blocks", "taskNV", ""); +#endif + if (qualifier.storage == EvqVaryingIn) { switch (language) { case EShLangVertex: @@ -3257,6 +3286,11 @@ void TParseContext::mergeQualifiers(const TSourceLoc& loc, TQualifier& dst, cons MERGE_SINGLETON(nopersp); #ifdef AMD_EXTENSIONS MERGE_SINGLETON(explicitInterp); +#endif +#ifdef NV_EXTENSIONS + MERGE_SINGLETON(perPrimitiveNV); + MERGE_SINGLETON(perViewNV); + MERGE_SINGLETON(perTaskNV); #endif MERGE_SINGLETON(patch); MERGE_SINGLETON(sample); @@ -3599,7 +3633,7 @@ void TParseContext::declareArray(const TSourceLoc& loc, const TString& identifie if (! symbolTable.atBuiltInLevel()) { if (isIoResizeArray(type)) { ioArraySymbolResizeList.push_back(symbol); - checkIoArraysConsistency(loc, true); + checkIoArraysConsistency(loc, true, type.getQualifier().isPerPrimitive()); } else fixIoArraySize(loc, symbol->getWritableType()); } @@ -3652,7 +3686,7 @@ void TParseContext::declareArray(const TSourceLoc& loc, const TString& identifie existingType.updateArraySizes(type); if (isIoResizeArray(type)) - checkIoArraysConsistency(loc); + checkIoArraysConsistency(loc, false, type.getQualifier().isPerPrimitive()); } // Policy and error check for needing a runtime sized array. @@ -3688,6 +3722,28 @@ bool TParseContext::isRuntimeLength(const TIntermTyped& base) const return false; } +#ifdef NV_EXTENSIONS +// Fix mesh view output array dimension +void TParseContext::resizeMeshViewDimension(const TSourceLoc& loc, TType& type) +{ + // see if member is a per-view attribute + if (type.getQualifier().isPerView()) { + // since we don't have the maxMeshViewCountNV set during parsing builtins, we hardcode the value + int maxViewCount = parsingBuiltins ? 4 : resources.maxMeshViewCountNV; + + if (! type.isArray()) { + error(loc, "requires an view array dimension", "perviewNV", ""); + } + else if (!type.isUnsizedArray() && type.getOuterArraySize() != maxViewCount) { + error(loc, "mesh view output array size must be gl_MaxMeshViewCountNV or implicitly sized", "[]", ""); + } + else if (type.isUnsizedArray()) { + type.changeOuterArraySize(maxViewCount); + } + } +} +#endif + // Returns true if the first argument to the #line directive is the line number for the next line. // // Desktop, pre-version 3.30: "After processing this directive @@ -3878,7 +3934,12 @@ void TParseContext::redeclareBuiltinBlock(const TSourceLoc& loc, TTypeList& newT profileRequires(loc, EEsProfile, 320, Num_AEP_shader_io_blocks, AEP_shader_io_blocks, feature); profileRequires(loc, ~EEsProfile, 410, E_GL_ARB_separate_shader_objects, feature); - if (blockName != "gl_PerVertex" && blockName != "gl_PerFragment") { + if (blockName != "gl_PerVertex" && blockName != "gl_PerFragment" +#ifdef NV_EXTENSIONS + && blockName != "gl_MeshPerVertexNV" && blockName != "gl_MeshPerPrimitiveNV" +#endif + ) + { error(loc, "cannot redeclare block: ", "block declaration", blockName.c_str()); return; } @@ -4054,7 +4115,7 @@ void TParseContext::redeclareBuiltinBlock(const TSourceLoc& loc, TTypeList& newT // Tracking for implicit sizing of array if (isIoResizeArray(block->getType())) { ioArraySymbolResizeList.push_back(block); - checkIoArraysConsistency(loc, true); + checkIoArraysConsistency(loc, true, block->getType().getQualifier().isPerPrimitive()); } else if (block->getType().isArray()) fixIoArraySize(loc, block->getWritableType()); @@ -4471,44 +4532,57 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi publicType.qualifier.layoutPushConstant = true; return; } - if (language == EShLangGeometry || language == EShLangTessEvaluation) { + if (language == EShLangGeometry || language == EShLangTessEvaluation +#ifdef NV_EXTENSIONS + || language == EShLangMeshNV +#endif + ) { if (id == TQualifier::getGeometryString(ElgTriangles)) { publicType.shaderQualifiers.geometry = ElgTriangles; return; } - if (language == EShLangGeometry) { + if (language == EShLangGeometry +#ifdef NV_EXTENSIONS + || language == EShLangMeshNV +#endif + ) { if (id == TQualifier::getGeometryString(ElgPoints)) { publicType.shaderQualifiers.geometry = ElgPoints; return; } - if (id == TQualifier::getGeometryString(ElgLineStrip)) { - publicType.shaderQualifiers.geometry = ElgLineStrip; - return; - } if (id == TQualifier::getGeometryString(ElgLines)) { publicType.shaderQualifiers.geometry = ElgLines; return; } - if (id == TQualifier::getGeometryString(ElgLinesAdjacency)) { - publicType.shaderQualifiers.geometry = ElgLinesAdjacency; - return; - } - if (id == TQualifier::getGeometryString(ElgTrianglesAdjacency)) { - publicType.shaderQualifiers.geometry = ElgTrianglesAdjacency; - return; - } - if (id == TQualifier::getGeometryString(ElgTriangleStrip)) { - publicType.shaderQualifiers.geometry = ElgTriangleStrip; - return; - } #ifdef NV_EXTENSIONS - if (id == "passthrough") { - requireExtensions(loc, 1, &E_SPV_NV_geometry_shader_passthrough, "geometry shader passthrough"); - publicType.qualifier.layoutPassthrough = true; - intermediate.setGeoPassthroughEXT(); - return; - } + if (language == EShLangGeometry) #endif + { + if (id == TQualifier::getGeometryString(ElgLineStrip)) { + publicType.shaderQualifiers.geometry = ElgLineStrip; + return; + } + if (id == TQualifier::getGeometryString(ElgLinesAdjacency)) { + publicType.shaderQualifiers.geometry = ElgLinesAdjacency; + return; + } + if (id == TQualifier::getGeometryString(ElgTrianglesAdjacency)) { + publicType.shaderQualifiers.geometry = ElgTrianglesAdjacency; + return; + } + if (id == TQualifier::getGeometryString(ElgTriangleStrip)) { + publicType.shaderQualifiers.geometry = ElgTriangleStrip; + return; + } +#ifdef NV_EXTENSIONS + if (id == "passthrough") { + requireExtensions(loc, 1, &E_SPV_NV_geometry_shader_passthrough, "geometry shader passthrough"); + publicType.qualifier.layoutPassthrough = true; + intermediate.setGeoPassthroughEXT(); + return; + } +#endif + } } else { assert(language == EShLangTessEvaluation); @@ -4863,10 +4937,37 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi } break; +#ifdef NV_EXTENSIONS + case EShLangMeshNV: + if (id == "max_vertices") { + publicType.shaderQualifiers.vertices = value; + if (value > resources.maxMeshOutputVerticesNV) + error(loc, "too large, must be less than gl_MaxMeshOutputVerticesNV", "max_vertices", ""); + return; + } + if (id == "max_primitives") { + publicType.shaderQualifiers.primitives = value; + if (value > resources.maxMeshOutputPrimitivesNV) + error(loc, "too large, must be less than gl_MaxMeshOutputPrimitivesNV", "max_primitives", ""); + return; + } + // Fall through + + case EShLangTaskNV: + // Fall through +#endif case EShLangCompute: if (id.compare(0, 11, "local_size_") == 0) { - profileRequires(loc, EEsProfile, 310, 0, "gl_WorkGroupSize"); - profileRequires(loc, ~EEsProfile, 430, E_GL_ARB_compute_shader, "gl_WorkGroupSize"); +#ifdef NV_EXTENSIONS + if (language == EShLangMeshNV || language == EShLangTaskNV) { + profileRequires(loc, ~EEsProfile, 450, E_GL_NV_mesh_shader, "gl_WorkGroupSize"); + } + else +#endif + { + profileRequires(loc, EEsProfile, 310, 0, "gl_WorkGroupSize"); + profileRequires(loc, ~EEsProfile, 430, E_GL_ARB_compute_shader, "gl_WorkGroupSize"); + } if (id.size() == 12 && value == 0) { error(loc, "must be at least 1", id.c_str(), ""); return; @@ -5013,9 +5114,10 @@ void TParseContext::layoutObjectCheck(const TSourceLoc& loc, const TSymbol& symb switch (qualifier.storage) { case EvqVaryingIn: case EvqVaryingOut: - if (type.getBasicType() != EbtBlock || - (!(*type.getStruct())[0].type->getQualifier().hasLocation() && - (*type.getStruct())[0].type->getQualifier().builtIn == EbvNone)) + if (!type.getQualifier().isTaskMemory() && + (type.getBasicType() != EbtBlock || + (!(*type.getStruct())[0].type->getQualifier().hasLocation() && + (*type.getStruct())[0].type->getQualifier().builtIn == EbvNone))) error(loc, "SPIR-V requires location for user input/output", "location", ""); break; default: @@ -5104,6 +5206,10 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type) case EvqVaryingOut: if (type.getBasicType() == EbtBlock) profileRequires(loc, ECoreProfile | ECompatibilityProfile, 440, E_GL_ARB_enhanced_layouts, "location qualifier on in/out block"); +#ifdef NV_EXTENSIONS + if (type.getQualifier().isTaskMemory()) + error(loc, "cannot apply to taskNV in/out blocks", "location", ""); +#endif break; case EvqUniform: case EvqBuffer: @@ -5355,7 +5461,7 @@ void TParseContext::layoutQualifierCheck(const TSourceLoc& loc, const TQualifier } if (qualifier.hasBinding()) { - if (! qualifier.isUniformOrBuffer()) + if (! qualifier.isUniformOrBuffer() && !qualifier.isTaskMemory()) error(loc, "requires uniform or buffer storage qualifier", "binding", ""); } if (qualifier.hasStream()) { @@ -5367,7 +5473,7 @@ void TParseContext::layoutQualifierCheck(const TSourceLoc& loc, const TQualifier error(loc, "can only be used on an output", "xfb layout qualifier", ""); } if (qualifier.hasUniformLayout()) { - if (! qualifier.isUniformOrBuffer()) { + if (! qualifier.isUniformOrBuffer() && !qualifier.isTaskMemory()) { if (qualifier.hasMatrix() || qualifier.hasPacking()) error(loc, "matrix or packing qualifiers can only be used on a uniform or buffer", "layout", ""); if (qualifier.hasOffset() || qualifier.hasAlign()) @@ -5408,13 +5514,25 @@ void TParseContext::checkNoShaderLayouts(const TSourceLoc& loc, const TShaderQua error(loc, message, "local_size id", ""); } if (shaderQualifiers.vertices != TQualifier::layoutNotSet) { - if (language == EShLangGeometry) + if (language == EShLangGeometry +#ifdef NV_EXTENSIONS + || language == EShLangMeshNV +#endif + ) error(loc, message, "max_vertices", ""); else if (language == EShLangTessControl) error(loc, message, "vertices", ""); else assert(0); } +#ifdef NV_EXTENSIONS + if (shaderQualifiers.primitives != TQualifier::layoutNotSet) { + if (language == EShLangMeshNV) + error(loc, message, "max_primitives", ""); + else + assert(0); + } +#endif if (shaderQualifiers.blendEquation) error(loc, message, "blend equation", ""); if (shaderQualifiers.numViews != TQualifier::layoutNotSet) @@ -6445,6 +6563,14 @@ void TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeList, con if (memberQualifier.storage != EvqTemporary && memberQualifier.storage != EvqGlobal && memberQualifier.storage != currentBlockQualifier.storage) error(memberLoc, "member storage qualifier cannot contradict block storage qualifier", memberType.getFieldName().c_str(), ""); memberQualifier.storage = currentBlockQualifier.storage; +#ifdef NV_EXTENSIONS + if (currentBlockQualifier.perPrimitiveNV) + memberQualifier.perPrimitiveNV = currentBlockQualifier.perPrimitiveNV; + if (currentBlockQualifier.perViewNV) + memberQualifier.perViewNV = currentBlockQualifier.perViewNV; + if (currentBlockQualifier.perTaskNV) + memberQualifier.perTaskNV = currentBlockQualifier.perTaskNV; +#endif if ((currentBlockQualifier.storage == EvqUniform || currentBlockQualifier.storage == EvqBuffer) && (memberQualifier.isInterpolation() || memberQualifier.isAuxiliary())) error(memberLoc, "member of uniform or buffer block cannot have an auxiliary or interpolation qualifier", memberType.getFieldName().c_str(), ""); if (memberType.isArray()) @@ -6490,6 +6616,12 @@ void TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeList, con if (currentBlockQualifier.layoutPushConstant && !currentBlockQualifier.hasPacking()) currentBlockQualifier.layoutPacking = ElpStd430; +#ifdef NV_EXTENSIONS + // Special case for "taskNV in/out", which has a default of std430, + if (currentBlockQualifier.perTaskNV && !currentBlockQualifier.hasPacking()) + currentBlockQualifier.layoutPacking = ElpStd430; +#endif + // fix and check for member layout qualifiers mergeObjectLayoutQualifiers(defaultQualification, currentBlockQualifier, true); @@ -6504,6 +6636,9 @@ void TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeList, con bool memberWithLocation = false; bool memberWithoutLocation = false; +#ifdef NV_EXTENSIONS + bool memberWithPerViewQualifier = false; +#endif for (unsigned int member = 0; member < typeList.size(); ++member) { TQualifier& memberQualifier = typeList[member].type->getQualifier(); const TSourceLoc& memberLoc = typeList[member].loc; @@ -6547,6 +6682,12 @@ void TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeList, con error(memberLoc, "can only be used with std140 or std430 layout packing", "offset/align", ""); } +#ifdef NV_EXTENSIONS + if (memberQualifier.isPerView()) { + memberWithPerViewQualifier = true; + } +#endif + TQualifier newMemberQualification = defaultQualification; mergeQualifiers(memberLoc, newMemberQualification, memberQualifier, false); memberQualifier = newMemberQualification; @@ -6561,6 +6702,14 @@ void TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeList, con for (unsigned int member = 0; member < typeList.size(); ++member) layoutTypeCheck(typeList[member].loc, *typeList[member].type); +#ifdef NV_EXTENSIONS + if (memberWithPerViewQualifier) { + for (unsigned int member = 0; member < typeList.size(); ++member) { + resizeMeshViewDimension(typeList[member].loc, *typeList[member].type); + } + } +#endif + // reverse merge, so that currentBlockQualifier now has all layout information // (can't use defaultQualification directly, it's missing other non-layout-default-class qualifiers) mergeObjectLayoutQualifiers(currentBlockQualifier, defaultQualification, true); @@ -6624,7 +6773,7 @@ void TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeList, con // fix up if (isIoResizeArray(blockType)) { ioArraySymbolResizeList.push_back(&variable); - checkIoArraysConsistency(loc, true); + checkIoArraysConsistency(loc, true, blockType.getQualifier().isPerPrimitive()); } else fixIoArraySize(loc, variable.getWritableType()); @@ -6652,16 +6801,39 @@ void TParseContext::blockStageIoCheck(const TSourceLoc& loc, const TQualifier& q profileRequires(loc, ~EEsProfile, 150, E_GL_ARB_separate_shader_objects, "input block"); // It is a compile-time error to have an input block in a vertex shader or an output block in a fragment shader // "Compute shaders do not permit user-defined input variables..." - requireStage(loc, (EShLanguageMask)(EShLangTessControlMask|EShLangTessEvaluationMask|EShLangGeometryMask|EShLangFragmentMask), "input block"); - if (language == EShLangFragment) + requireStage(loc, (EShLanguageMask)(EShLangTessControlMask|EShLangTessEvaluationMask|EShLangGeometryMask|EShLangFragmentMask +#ifdef NV_EXTENSIONS + |EShLangMeshNVMask +#endif + ), "input block"); + if (language == EShLangFragment) { profileRequires(loc, EEsProfile, 320, Num_AEP_shader_io_blocks, AEP_shader_io_blocks, "fragment input block"); + } +#ifdef NV_EXTENSIONS + else if (language == EShLangMeshNV && ! qualifier.isTaskMemory()) { + error(loc, "input blocks cannot be used in a mesh shader", "out", ""); + } +#endif break; case EvqVaryingOut: profileRequires(loc, ~EEsProfile, 150, E_GL_ARB_separate_shader_objects, "output block"); - requireStage(loc, (EShLanguageMask)(EShLangVertexMask|EShLangTessControlMask|EShLangTessEvaluationMask|EShLangGeometryMask), "output block"); + requireStage(loc, (EShLanguageMask)(EShLangVertexMask|EShLangTessControlMask|EShLangTessEvaluationMask|EShLangGeometryMask +#ifdef NV_EXTENSIONS + |EShLangMeshNVMask|EShLangTaskNVMask +#endif + ), "output block"); // ES 310 can have a block before shader_io is turned on, so skip this test for built-ins - if (language == EShLangVertex && ! parsingBuiltins) + if (language == EShLangVertex && ! parsingBuiltins) { profileRequires(loc, EEsProfile, 320, Num_AEP_shader_io_blocks, AEP_shader_io_blocks, "vertex output block"); + } +#ifdef NV_EXTENSIONS + else if (language == EShLangMeshNV && qualifier.isTaskMemory()) { + error(loc, "can only use on input blocks in mesh shader", "taskNV", ""); + } + else if (language == EShLangTaskNV && ! qualifier.isTaskMemory()) { + error(loc, "output blocks cannot be used in a task shader", "out", ""); + } +#endif break; default: error(loc, "only uniform, buffer, in, or out blocks are supported", blockName->c_str(), ""); @@ -6699,6 +6871,10 @@ void TParseContext::blockQualifierCheck(const TSourceLoc& loc, const TQualifier& error(loc, "cannot use invariant qualifier on an interface block", "invariant", ""); if (qualifier.layoutPushConstant) intermediate.addPushConstantCount(); +#ifdef NV_EXTENSIONS + if (qualifier.perTaskNV) + intermediate.addTaskNVCount(); +#endif } // @@ -6784,7 +6960,7 @@ void TParseContext::fixBlockXfbOffsets(TQualifier& qualifier, TTypeList& typeLis // void TParseContext::fixBlockUniformOffsets(TQualifier& qualifier, TTypeList& typeList) { - if (! qualifier.isUniformOrBuffer()) + if (!qualifier.isUniformOrBuffer() && !qualifier.isTaskMemory()) return; if (qualifier.layoutPacking != ElpStd140 && qualifier.layoutPacking != ElpStd430) return; @@ -6916,7 +7092,11 @@ void TParseContext::invariantCheck(const TSourceLoc& loc, const TQualifier& qual void TParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc, const TPublicType& publicType) { if (publicType.shaderQualifiers.vertices != TQualifier::layoutNotSet) { +#ifdef NV_EXTENSIONS + assert(language == EShLangTessControl || language == EShLangGeometry || language == EShLangMeshNV); +#else assert(language == EShLangTessControl || language == EShLangGeometry); +#endif const char* id = (language == EShLangTessControl) ? "vertices" : "max_vertices"; if (publicType.qualifier.storage != EvqVaryingOut) @@ -6927,6 +7107,17 @@ void TParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc, con if (language == EShLangTessControl) checkIoArraysConsistency(loc); } +#ifdef NV_EXTENSIONS + if (publicType.shaderQualifiers.primitives != TQualifier::layoutNotSet) { + assert(language == EShLangMeshNV); + const char* id = "max_primitives"; + + if (publicType.qualifier.storage != EvqVaryingOut) + error(loc, "can only apply to 'out'", id, ""); + if (! intermediate.setPrimitives(publicType.shaderQualifiers.primitives)) + error(loc, "cannot change previously set layout value", id, ""); + } +#endif if (publicType.shaderQualifiers.invocations != TQualifier::layoutNotSet) { if (publicType.qualifier.storage != EvqVaryingIn) error(loc, "can only apply to 'in'", "invocations", ""); @@ -6943,6 +7134,12 @@ void TParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc, con case ElgTrianglesAdjacency: case ElgQuads: case ElgIsolines: +#ifdef NV_EXTENSIONS + if (language == EShLangMeshNV) { + error(loc, "cannot apply to input", TQualifier::getGeometryString(publicType.shaderQualifiers.geometry), ""); + break; + } +#endif if (intermediate.setInputPrimitive(publicType.shaderQualifiers.geometry)) { if (language == EShLangGeometry) checkIoArraysConsistency(loc); @@ -6954,6 +7151,15 @@ void TParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc, con } } else if (publicType.qualifier.storage == EvqVaryingOut) { switch (publicType.shaderQualifiers.geometry) { +#ifdef NV_EXTENSIONS + case ElgLines: + case ElgTriangles: + if (language != EShLangMeshNV) { + error(loc, "cannot apply to 'out'", TQualifier::getGeometryString(publicType.shaderQualifiers.geometry), ""); + break; + } +#endif + // Fall through case ElgPoints: case ElgLineStrip: case ElgTriangleStrip: @@ -6993,14 +7199,41 @@ void TParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc, con error(loc, "cannot change previously set size", "local_size", ""); else { int max = 0; - switch (i) { - case 0: max = resources.maxComputeWorkGroupSizeX; break; - case 1: max = resources.maxComputeWorkGroupSizeY; break; - case 2: max = resources.maxComputeWorkGroupSizeZ; break; - default: break; + if (language == EShLangCompute) { + switch (i) { + case 0: max = resources.maxComputeWorkGroupSizeX; break; + case 1: max = resources.maxComputeWorkGroupSizeY; break; + case 2: max = resources.maxComputeWorkGroupSizeZ; break; + default: break; + } + if (intermediate.getLocalSize(i) > (unsigned int)max) + error(loc, "too large; see gl_MaxComputeWorkGroupSize", "local_size", ""); + } +#ifdef NV_EXTENSIONS + else if (language == EShLangMeshNV) { + switch (i) { + case 0: max = resources.maxMeshWorkGroupSizeX_NV; break; + case 1: max = resources.maxMeshWorkGroupSizeY_NV; break; + case 2: max = resources.maxMeshWorkGroupSizeZ_NV; break; + default: break; + } + if (intermediate.getLocalSize(i) > (unsigned int)max) + error(loc, "too large; see gl_MaxMeshWorkGroupSizeNV", "local_size", ""); + } + else if (language == EShLangTaskNV) { + switch (i) { + case 0: max = resources.maxTaskWorkGroupSizeX_NV; break; + case 1: max = resources.maxTaskWorkGroupSizeY_NV; break; + case 2: max = resources.maxTaskWorkGroupSizeZ_NV; break; + default: break; + } + if (intermediate.getLocalSize(i) > (unsigned int)max) + error(loc, "too large; see gl_MaxTaskWorkGroupSizeNV", "local_size", ""); + } +#endif + else { + assert(0); } - if (intermediate.getLocalSize(i) > (unsigned int)max) - error(loc, "too large; see gl_MaxComputeWorkGroupSize", "local_size", ""); // Fix the existing constant gl_WorkGroupSize with this new information. TVariable* workGroupSize = getEditableVariable("gl_WorkGroupSize"); diff --git a/glslang/MachineIndependent/ParseHelper.h b/glslang/MachineIndependent/ParseHelper.h index e34bbbca1..0ca9503c8 100644 --- a/glslang/MachineIndependent/ParseHelper.h +++ b/glslang/MachineIndependent/ParseHelper.h @@ -298,8 +298,8 @@ public: void fixIoArraySize(const TSourceLoc&, TType&); void ioArrayCheck(const TSourceLoc&, const TType&, const TString& identifier); void handleIoResizeArrayAccess(const TSourceLoc&, TIntermTyped* base); - void checkIoArraysConsistency(const TSourceLoc&, bool tailOnly = false); - int getIoArrayImplicitSize() const; + void checkIoArraysConsistency(const TSourceLoc&, bool tailOnly = false, bool isPerPrimitive = false); + int getIoArrayImplicitSize(bool isPerPrimitive = false) const; void checkIoArrayConsistency(const TSourceLoc&, int requiredSize, const char* feature, TType&, const TString&); TIntermTyped* handleBinaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* left, TIntermTyped* right); @@ -423,6 +423,9 @@ public: // Determine loop control from attributes void handleLoopAttributes(const TAttributes& attributes, TIntermNode*); +#ifdef NV_EXTENSIONS + void resizeMeshViewDimension(const TSourceLoc&, TType&); +#endif protected: void nonInitConstCheck(const TSourceLoc&, TString& identifier, TType& type); void inheritGlobalDefaults(TQualifier& dst) const; diff --git a/glslang/MachineIndependent/Scan.cpp b/glslang/MachineIndependent/Scan.cpp index 722d73d09..0f6ebea4a 100644 --- a/glslang/MachineIndependent/Scan.cpp +++ b/glslang/MachineIndependent/Scan.cpp @@ -700,6 +700,12 @@ void TScanContext::fillInKeywordMap() (*KeywordMap)["resource"] = RESOURCE; (*KeywordMap)["superp"] = SUPERP; +#ifdef NV_EXTENSIONS + (*KeywordMap)["perprimitiveNV"] = PERPRIMITIVENV; + (*KeywordMap)["perviewNV"] = PERVIEWNV; + (*KeywordMap)["taskNV"] = PERTASKNV; +#endif + ReservedSet = new std::unordered_set; ReservedSet->insert("common"); @@ -1565,6 +1571,16 @@ int TScanContext::tokenizeIdentifier() return identifierOrReserved(reserved); } +#ifdef NV_EXTENSIONS + case PERPRIMITIVENV: + case PERVIEWNV: + case PERTASKNV: + if (parseContext.profile != EEsProfile && + (parseContext.version >= 450 || parseContext.extensionTurnedOn(E_GL_NV_mesh_shader))) + return keyword; + return identifierOrType(); +#endif + default: parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc); return 0; diff --git a/glslang/MachineIndependent/ShaderLang.cpp b/glslang/MachineIndependent/ShaderLang.cpp index c99f95811..f9d9faffc 100755 --- a/glslang/MachineIndependent/ShaderLang.cpp +++ b/glslang/MachineIndependent/ShaderLang.cpp @@ -347,6 +347,18 @@ bool InitializeSymbolTables(TInfoSink& infoSink, TSymbolTable** commonTable, TS InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangCompute, source, infoSink, commonTable, symbolTables); +#ifdef NV_EXTENSIONS + // check for mesh + if (profile != EEsProfile && version >= 450) + InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangMeshNV, source, + infoSink, commonTable, symbolTables); + + // check for task + if (profile != EEsProfile && version >= 450) + InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangTaskNV, source, + infoSink, commonTable, symbolTables); +#endif + return true; } @@ -570,6 +582,16 @@ bool DeduceVersionProfile(TInfoSink& infoSink, EShLanguage stage, bool versionNo version = profile == EEsProfile ? 310 : 420; } break; +#ifdef NV_EXTENSIONS + case EShLangMeshNV: + case EShLangTaskNV: + if ((profile == EEsProfile) || + (profile != EEsProfile && version < 450)) { + correct = false; + infoSink.info.message(EPrefixError, "#version: mesh/task shaders require non-es profile with version 450 or above"); + version = 450; + } +#endif default: break; } diff --git a/glslang/MachineIndependent/Versions.cpp b/glslang/MachineIndependent/Versions.cpp index 82a0ac2b9..39165200c 100644 --- a/glslang/MachineIndependent/Versions.cpp +++ b/glslang/MachineIndependent/Versions.cpp @@ -238,6 +238,7 @@ void TParseVersions::initializeExtensionBehavior() extensionBehavior[E_GL_NV_fragment_shader_barycentric] = EBhDisable; extensionBehavior[E_GL_NV_compute_shader_derivatives] = EBhDisable; extensionBehavior[E_GL_NV_shader_texture_footprint] = EBhDisable; + extensionBehavior[E_GL_NV_mesh_shader] = EBhDisable; #endif // AEP @@ -411,6 +412,7 @@ void TParseVersions::getPreamble(std::string& preamble) "#define GL_NV_fragment_shader_barycentric 1\n" "#define GL_NV_compute_shader_derivatives 1\n" "#define GL_NV_shader_texture_footprint 1\n" + "#define GL_NV_mesh_shader 1\n" #endif "#define GL_KHX_shader_explicit_arithmetic_types 1\n" "#define GL_KHX_shader_explicit_arithmetic_types_int8 1\n" @@ -498,6 +500,10 @@ const char* StageName(EShLanguage stage) case EShLangGeometry: return "geometry"; case EShLangFragment: return "fragment"; case EShLangCompute: return "compute"; +#ifdef NV_EXTENSIONS + case EShLangMeshNV: return "mesh"; + case EShLangTaskNV: return "task"; +#endif default: return "unknown stage"; } } diff --git a/glslang/MachineIndependent/Versions.h b/glslang/MachineIndependent/Versions.h index 2b3cb1216..27760cf55 100644 --- a/glslang/MachineIndependent/Versions.h +++ b/glslang/MachineIndependent/Versions.h @@ -210,6 +210,8 @@ const char* const E_GL_NV_shader_subgroup_partitioned = "GL_NV_shader_ const char* const E_GL_NV_fragment_shader_barycentric = "GL_NV_fragment_shader_barycentric"; const char* const E_GL_NV_compute_shader_derivatives = "GL_NV_compute_shader_derivatives"; const char* const E_GL_NV_shader_texture_footprint = "GL_NV_shader_texture_footprint"; +const char* const E_GL_NV_mesh_shader = "GL_NV_mesh_shader"; + // Arrays of extensions for the above viewportEXTs duplications const char* const viewportEXTs[] = { E_GL_ARB_shader_viewport_layer_array, E_GL_NV_viewport_array2 }; diff --git a/glslang/MachineIndependent/glslang.y b/glslang/MachineIndependent/glslang.y index 64273fbe2..35d6435d8 100644 --- a/glslang/MachineIndependent/glslang.y +++ b/glslang/MachineIndependent/glslang.y @@ -146,7 +146,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %token F16VEC2 F16VEC3 F16VEC4 F16MAT2 F16MAT3 F16MAT4 %token F32VEC2 F32VEC3 F32VEC4 F32MAT2 F32MAT3 F32MAT4 %token F64VEC2 F64VEC3 F64VEC4 F64MAT2 F64MAT3 F64MAT4 -%token NOPERSPECTIVE FLAT SMOOTH LAYOUT EXPLICITINTERPAMD PERVERTEXNV +%token NOPERSPECTIVE FLAT SMOOTH LAYOUT EXPLICITINTERPAMD PERVERTEXNV PERPRIMITIVENV PERVIEWNV PERTASKNV %token MAT2X2 MAT2X3 MAT2X4 %token MAT3X2 MAT3X3 MAT3X4 @@ -1152,6 +1152,30 @@ interpolation_qualifier parseContext.profileRequires($1.loc, EEsProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric"); $$.init($1.loc); $$.qualifier.pervertexNV = true; +#endif + } + | PERPRIMITIVENV { +#ifdef NV_EXTENSIONS + parseContext.globalCheck($1.loc, "perprimitiveNV"); + parseContext.profileRequires($1.loc, ECoreProfile, 450, E_GL_NV_mesh_shader, "perprimitiveNV"); + $$.init($1.loc); + $$.qualifier.perPrimitiveNV = true; +#endif + } + | PERVIEWNV { +#ifdef NV_EXTENSIONS + parseContext.globalCheck($1.loc, "perviewNV"); + parseContext.profileRequires($1.loc, ECoreProfile, 450, E_GL_NV_mesh_shader, "perviewNV"); + $$.init($1.loc); + $$.qualifier.perViewNV = true; +#endif + } + | PERTASKNV { +#ifdef NV_EXTENSIONS + parseContext.globalCheck($1.loc, "taskNV"); + parseContext.profileRequires($1.loc, ECoreProfile, 450, E_GL_NV_mesh_shader, "taskNV"); + $$.init($1.loc); + $$.qualifier.perTaskNV = true; #endif } ; @@ -1319,7 +1343,11 @@ storage_qualifier parseContext.globalCheck($1.loc, "shared"); parseContext.profileRequires($1.loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared"); parseContext.profileRequires($1.loc, EEsProfile, 310, 0, "shared"); +#ifdef NV_EXTENSIONS + parseContext.requireStage($1.loc, (EShLanguageMask)(EShLangComputeMask | EShLangMeshNVMask | EShLangTaskNVMask), "shared"); +#else parseContext.requireStage($1.loc, EShLangCompute, "shared"); +#endif $$.init($1.loc); $$.qualifier.storage = EvqShared; } diff --git a/glslang/MachineIndependent/glslang_tab.cpp b/glslang/MachineIndependent/glslang_tab.cpp index 97281b422..b06264298 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp +++ b/glslang/MachineIndependent/glslang_tab.cpp @@ -243,280 +243,283 @@ extern int yydebug; LAYOUT = 375, EXPLICITINTERPAMD = 376, PERVERTEXNV = 377, - MAT2X2 = 378, - MAT2X3 = 379, - MAT2X4 = 380, - MAT3X2 = 381, - MAT3X3 = 382, - MAT3X4 = 383, - MAT4X2 = 384, - MAT4X3 = 385, - MAT4X4 = 386, - DMAT2X2 = 387, - DMAT2X3 = 388, - DMAT2X4 = 389, - DMAT3X2 = 390, - DMAT3X3 = 391, - DMAT3X4 = 392, - DMAT4X2 = 393, - DMAT4X3 = 394, - DMAT4X4 = 395, - F16MAT2X2 = 396, - F16MAT2X3 = 397, - F16MAT2X4 = 398, - F16MAT3X2 = 399, - F16MAT3X3 = 400, - F16MAT3X4 = 401, - F16MAT4X2 = 402, - F16MAT4X3 = 403, - F16MAT4X4 = 404, - F32MAT2X2 = 405, - F32MAT2X3 = 406, - F32MAT2X4 = 407, - F32MAT3X2 = 408, - F32MAT3X3 = 409, - F32MAT3X4 = 410, - F32MAT4X2 = 411, - F32MAT4X3 = 412, - F32MAT4X4 = 413, - F64MAT2X2 = 414, - F64MAT2X3 = 415, - F64MAT2X4 = 416, - F64MAT3X2 = 417, - F64MAT3X3 = 418, - F64MAT3X4 = 419, - F64MAT4X2 = 420, - F64MAT4X3 = 421, - F64MAT4X4 = 422, - ATOMIC_UINT = 423, - SAMPLER1D = 424, - SAMPLER2D = 425, - SAMPLER3D = 426, - SAMPLERCUBE = 427, - SAMPLER1DSHADOW = 428, - SAMPLER2DSHADOW = 429, - SAMPLERCUBESHADOW = 430, - SAMPLER1DARRAY = 431, - SAMPLER2DARRAY = 432, - SAMPLER1DARRAYSHADOW = 433, - SAMPLER2DARRAYSHADOW = 434, - ISAMPLER1D = 435, - ISAMPLER2D = 436, - ISAMPLER3D = 437, - ISAMPLERCUBE = 438, - ISAMPLER1DARRAY = 439, - ISAMPLER2DARRAY = 440, - USAMPLER1D = 441, - USAMPLER2D = 442, - USAMPLER3D = 443, - USAMPLERCUBE = 444, - USAMPLER1DARRAY = 445, - USAMPLER2DARRAY = 446, - SAMPLER2DRECT = 447, - SAMPLER2DRECTSHADOW = 448, - ISAMPLER2DRECT = 449, - USAMPLER2DRECT = 450, - SAMPLERBUFFER = 451, - ISAMPLERBUFFER = 452, - USAMPLERBUFFER = 453, - SAMPLERCUBEARRAY = 454, - SAMPLERCUBEARRAYSHADOW = 455, - ISAMPLERCUBEARRAY = 456, - USAMPLERCUBEARRAY = 457, - SAMPLER2DMS = 458, - ISAMPLER2DMS = 459, - USAMPLER2DMS = 460, - SAMPLER2DMSARRAY = 461, - ISAMPLER2DMSARRAY = 462, - USAMPLER2DMSARRAY = 463, - SAMPLEREXTERNALOES = 464, - F16SAMPLER1D = 465, - F16SAMPLER2D = 466, - F16SAMPLER3D = 467, - F16SAMPLER2DRECT = 468, - F16SAMPLERCUBE = 469, - F16SAMPLER1DARRAY = 470, - F16SAMPLER2DARRAY = 471, - F16SAMPLERCUBEARRAY = 472, - F16SAMPLERBUFFER = 473, - F16SAMPLER2DMS = 474, - F16SAMPLER2DMSARRAY = 475, - F16SAMPLER1DSHADOW = 476, - F16SAMPLER2DSHADOW = 477, - F16SAMPLER1DARRAYSHADOW = 478, - F16SAMPLER2DARRAYSHADOW = 479, - F16SAMPLER2DRECTSHADOW = 480, - F16SAMPLERCUBESHADOW = 481, - F16SAMPLERCUBEARRAYSHADOW = 482, - SAMPLER = 483, - SAMPLERSHADOW = 484, - TEXTURE1D = 485, - TEXTURE2D = 486, - TEXTURE3D = 487, - TEXTURECUBE = 488, - TEXTURE1DARRAY = 489, - TEXTURE2DARRAY = 490, - ITEXTURE1D = 491, - ITEXTURE2D = 492, - ITEXTURE3D = 493, - ITEXTURECUBE = 494, - ITEXTURE1DARRAY = 495, - ITEXTURE2DARRAY = 496, - UTEXTURE1D = 497, - UTEXTURE2D = 498, - UTEXTURE3D = 499, - UTEXTURECUBE = 500, - UTEXTURE1DARRAY = 501, - UTEXTURE2DARRAY = 502, - TEXTURE2DRECT = 503, - ITEXTURE2DRECT = 504, - UTEXTURE2DRECT = 505, - TEXTUREBUFFER = 506, - ITEXTUREBUFFER = 507, - UTEXTUREBUFFER = 508, - TEXTURECUBEARRAY = 509, - ITEXTURECUBEARRAY = 510, - UTEXTURECUBEARRAY = 511, - TEXTURE2DMS = 512, - ITEXTURE2DMS = 513, - UTEXTURE2DMS = 514, - TEXTURE2DMSARRAY = 515, - ITEXTURE2DMSARRAY = 516, - UTEXTURE2DMSARRAY = 517, - F16TEXTURE1D = 518, - F16TEXTURE2D = 519, - F16TEXTURE3D = 520, - F16TEXTURE2DRECT = 521, - F16TEXTURECUBE = 522, - F16TEXTURE1DARRAY = 523, - F16TEXTURE2DARRAY = 524, - F16TEXTURECUBEARRAY = 525, - F16TEXTUREBUFFER = 526, - F16TEXTURE2DMS = 527, - F16TEXTURE2DMSARRAY = 528, - SUBPASSINPUT = 529, - SUBPASSINPUTMS = 530, - ISUBPASSINPUT = 531, - ISUBPASSINPUTMS = 532, - USUBPASSINPUT = 533, - USUBPASSINPUTMS = 534, - F16SUBPASSINPUT = 535, - F16SUBPASSINPUTMS = 536, - IMAGE1D = 537, - IIMAGE1D = 538, - UIMAGE1D = 539, - IMAGE2D = 540, - IIMAGE2D = 541, - UIMAGE2D = 542, - IMAGE3D = 543, - IIMAGE3D = 544, - UIMAGE3D = 545, - IMAGE2DRECT = 546, - IIMAGE2DRECT = 547, - UIMAGE2DRECT = 548, - IMAGECUBE = 549, - IIMAGECUBE = 550, - UIMAGECUBE = 551, - IMAGEBUFFER = 552, - IIMAGEBUFFER = 553, - UIMAGEBUFFER = 554, - IMAGE1DARRAY = 555, - IIMAGE1DARRAY = 556, - UIMAGE1DARRAY = 557, - IMAGE2DARRAY = 558, - IIMAGE2DARRAY = 559, - UIMAGE2DARRAY = 560, - IMAGECUBEARRAY = 561, - IIMAGECUBEARRAY = 562, - UIMAGECUBEARRAY = 563, - IMAGE2DMS = 564, - IIMAGE2DMS = 565, - UIMAGE2DMS = 566, - IMAGE2DMSARRAY = 567, - IIMAGE2DMSARRAY = 568, - UIMAGE2DMSARRAY = 569, - F16IMAGE1D = 570, - F16IMAGE2D = 571, - F16IMAGE3D = 572, - F16IMAGE2DRECT = 573, - F16IMAGECUBE = 574, - F16IMAGE1DARRAY = 575, - F16IMAGE2DARRAY = 576, - F16IMAGECUBEARRAY = 577, - F16IMAGEBUFFER = 578, - F16IMAGE2DMS = 579, - F16IMAGE2DMSARRAY = 580, - STRUCT = 581, - VOID = 582, - WHILE = 583, - IDENTIFIER = 584, - TYPE_NAME = 585, - FLOATCONSTANT = 586, - DOUBLECONSTANT = 587, - INT16CONSTANT = 588, - UINT16CONSTANT = 589, - INT32CONSTANT = 590, - UINT32CONSTANT = 591, - INTCONSTANT = 592, - UINTCONSTANT = 593, - INT64CONSTANT = 594, - UINT64CONSTANT = 595, - BOOLCONSTANT = 596, - FLOAT16CONSTANT = 597, - LEFT_OP = 598, - RIGHT_OP = 599, - INC_OP = 600, - DEC_OP = 601, - LE_OP = 602, - GE_OP = 603, - EQ_OP = 604, - NE_OP = 605, - AND_OP = 606, - OR_OP = 607, - XOR_OP = 608, - MUL_ASSIGN = 609, - DIV_ASSIGN = 610, - ADD_ASSIGN = 611, - MOD_ASSIGN = 612, - LEFT_ASSIGN = 613, - RIGHT_ASSIGN = 614, - AND_ASSIGN = 615, - XOR_ASSIGN = 616, - OR_ASSIGN = 617, - SUB_ASSIGN = 618, - LEFT_PAREN = 619, - RIGHT_PAREN = 620, - LEFT_BRACKET = 621, - RIGHT_BRACKET = 622, - LEFT_BRACE = 623, - RIGHT_BRACE = 624, - DOT = 625, - COMMA = 626, - COLON = 627, - EQUAL = 628, - SEMICOLON = 629, - BANG = 630, - DASH = 631, - TILDE = 632, - PLUS = 633, - STAR = 634, - SLASH = 635, - PERCENT = 636, - LEFT_ANGLE = 637, - RIGHT_ANGLE = 638, - VERTICAL_BAR = 639, - CARET = 640, - AMPERSAND = 641, - QUESTION = 642, - INVARIANT = 643, - PRECISE = 644, - HIGH_PRECISION = 645, - MEDIUM_PRECISION = 646, - LOW_PRECISION = 647, - PRECISION = 648, - PACKED = 649, - RESOURCE = 650, - SUPERP = 651 + PERPRIMITIVENV = 378, + PERVIEWNV = 379, + PERTASKNV = 380, + MAT2X2 = 381, + MAT2X3 = 382, + MAT2X4 = 383, + MAT3X2 = 384, + MAT3X3 = 385, + MAT3X4 = 386, + MAT4X2 = 387, + MAT4X3 = 388, + MAT4X4 = 389, + DMAT2X2 = 390, + DMAT2X3 = 391, + DMAT2X4 = 392, + DMAT3X2 = 393, + DMAT3X3 = 394, + DMAT3X4 = 395, + DMAT4X2 = 396, + DMAT4X3 = 397, + DMAT4X4 = 398, + F16MAT2X2 = 399, + F16MAT2X3 = 400, + F16MAT2X4 = 401, + F16MAT3X2 = 402, + F16MAT3X3 = 403, + F16MAT3X4 = 404, + F16MAT4X2 = 405, + F16MAT4X3 = 406, + F16MAT4X4 = 407, + F32MAT2X2 = 408, + F32MAT2X3 = 409, + F32MAT2X4 = 410, + F32MAT3X2 = 411, + F32MAT3X3 = 412, + F32MAT3X4 = 413, + F32MAT4X2 = 414, + F32MAT4X3 = 415, + F32MAT4X4 = 416, + F64MAT2X2 = 417, + F64MAT2X3 = 418, + F64MAT2X4 = 419, + F64MAT3X2 = 420, + F64MAT3X3 = 421, + F64MAT3X4 = 422, + F64MAT4X2 = 423, + F64MAT4X3 = 424, + F64MAT4X4 = 425, + ATOMIC_UINT = 426, + SAMPLER1D = 427, + SAMPLER2D = 428, + SAMPLER3D = 429, + SAMPLERCUBE = 430, + SAMPLER1DSHADOW = 431, + SAMPLER2DSHADOW = 432, + SAMPLERCUBESHADOW = 433, + SAMPLER1DARRAY = 434, + SAMPLER2DARRAY = 435, + SAMPLER1DARRAYSHADOW = 436, + SAMPLER2DARRAYSHADOW = 437, + ISAMPLER1D = 438, + ISAMPLER2D = 439, + ISAMPLER3D = 440, + ISAMPLERCUBE = 441, + ISAMPLER1DARRAY = 442, + ISAMPLER2DARRAY = 443, + USAMPLER1D = 444, + USAMPLER2D = 445, + USAMPLER3D = 446, + USAMPLERCUBE = 447, + USAMPLER1DARRAY = 448, + USAMPLER2DARRAY = 449, + SAMPLER2DRECT = 450, + SAMPLER2DRECTSHADOW = 451, + ISAMPLER2DRECT = 452, + USAMPLER2DRECT = 453, + SAMPLERBUFFER = 454, + ISAMPLERBUFFER = 455, + USAMPLERBUFFER = 456, + SAMPLERCUBEARRAY = 457, + SAMPLERCUBEARRAYSHADOW = 458, + ISAMPLERCUBEARRAY = 459, + USAMPLERCUBEARRAY = 460, + SAMPLER2DMS = 461, + ISAMPLER2DMS = 462, + USAMPLER2DMS = 463, + SAMPLER2DMSARRAY = 464, + ISAMPLER2DMSARRAY = 465, + USAMPLER2DMSARRAY = 466, + SAMPLEREXTERNALOES = 467, + F16SAMPLER1D = 468, + F16SAMPLER2D = 469, + F16SAMPLER3D = 470, + F16SAMPLER2DRECT = 471, + F16SAMPLERCUBE = 472, + F16SAMPLER1DARRAY = 473, + F16SAMPLER2DARRAY = 474, + F16SAMPLERCUBEARRAY = 475, + F16SAMPLERBUFFER = 476, + F16SAMPLER2DMS = 477, + F16SAMPLER2DMSARRAY = 478, + F16SAMPLER1DSHADOW = 479, + F16SAMPLER2DSHADOW = 480, + F16SAMPLER1DARRAYSHADOW = 481, + F16SAMPLER2DARRAYSHADOW = 482, + F16SAMPLER2DRECTSHADOW = 483, + F16SAMPLERCUBESHADOW = 484, + F16SAMPLERCUBEARRAYSHADOW = 485, + SAMPLER = 486, + SAMPLERSHADOW = 487, + TEXTURE1D = 488, + TEXTURE2D = 489, + TEXTURE3D = 490, + TEXTURECUBE = 491, + TEXTURE1DARRAY = 492, + TEXTURE2DARRAY = 493, + ITEXTURE1D = 494, + ITEXTURE2D = 495, + ITEXTURE3D = 496, + ITEXTURECUBE = 497, + ITEXTURE1DARRAY = 498, + ITEXTURE2DARRAY = 499, + UTEXTURE1D = 500, + UTEXTURE2D = 501, + UTEXTURE3D = 502, + UTEXTURECUBE = 503, + UTEXTURE1DARRAY = 504, + UTEXTURE2DARRAY = 505, + TEXTURE2DRECT = 506, + ITEXTURE2DRECT = 507, + UTEXTURE2DRECT = 508, + TEXTUREBUFFER = 509, + ITEXTUREBUFFER = 510, + UTEXTUREBUFFER = 511, + TEXTURECUBEARRAY = 512, + ITEXTURECUBEARRAY = 513, + UTEXTURECUBEARRAY = 514, + TEXTURE2DMS = 515, + ITEXTURE2DMS = 516, + UTEXTURE2DMS = 517, + TEXTURE2DMSARRAY = 518, + ITEXTURE2DMSARRAY = 519, + UTEXTURE2DMSARRAY = 520, + F16TEXTURE1D = 521, + F16TEXTURE2D = 522, + F16TEXTURE3D = 523, + F16TEXTURE2DRECT = 524, + F16TEXTURECUBE = 525, + F16TEXTURE1DARRAY = 526, + F16TEXTURE2DARRAY = 527, + F16TEXTURECUBEARRAY = 528, + F16TEXTUREBUFFER = 529, + F16TEXTURE2DMS = 530, + F16TEXTURE2DMSARRAY = 531, + SUBPASSINPUT = 532, + SUBPASSINPUTMS = 533, + ISUBPASSINPUT = 534, + ISUBPASSINPUTMS = 535, + USUBPASSINPUT = 536, + USUBPASSINPUTMS = 537, + F16SUBPASSINPUT = 538, + F16SUBPASSINPUTMS = 539, + IMAGE1D = 540, + IIMAGE1D = 541, + UIMAGE1D = 542, + IMAGE2D = 543, + IIMAGE2D = 544, + UIMAGE2D = 545, + IMAGE3D = 546, + IIMAGE3D = 547, + UIMAGE3D = 548, + IMAGE2DRECT = 549, + IIMAGE2DRECT = 550, + UIMAGE2DRECT = 551, + IMAGECUBE = 552, + IIMAGECUBE = 553, + UIMAGECUBE = 554, + IMAGEBUFFER = 555, + IIMAGEBUFFER = 556, + UIMAGEBUFFER = 557, + IMAGE1DARRAY = 558, + IIMAGE1DARRAY = 559, + UIMAGE1DARRAY = 560, + IMAGE2DARRAY = 561, + IIMAGE2DARRAY = 562, + UIMAGE2DARRAY = 563, + IMAGECUBEARRAY = 564, + IIMAGECUBEARRAY = 565, + UIMAGECUBEARRAY = 566, + IMAGE2DMS = 567, + IIMAGE2DMS = 568, + UIMAGE2DMS = 569, + IMAGE2DMSARRAY = 570, + IIMAGE2DMSARRAY = 571, + UIMAGE2DMSARRAY = 572, + F16IMAGE1D = 573, + F16IMAGE2D = 574, + F16IMAGE3D = 575, + F16IMAGE2DRECT = 576, + F16IMAGECUBE = 577, + F16IMAGE1DARRAY = 578, + F16IMAGE2DARRAY = 579, + F16IMAGECUBEARRAY = 580, + F16IMAGEBUFFER = 581, + F16IMAGE2DMS = 582, + F16IMAGE2DMSARRAY = 583, + STRUCT = 584, + VOID = 585, + WHILE = 586, + IDENTIFIER = 587, + TYPE_NAME = 588, + FLOATCONSTANT = 589, + DOUBLECONSTANT = 590, + INT16CONSTANT = 591, + UINT16CONSTANT = 592, + INT32CONSTANT = 593, + UINT32CONSTANT = 594, + INTCONSTANT = 595, + UINTCONSTANT = 596, + INT64CONSTANT = 597, + UINT64CONSTANT = 598, + BOOLCONSTANT = 599, + FLOAT16CONSTANT = 600, + LEFT_OP = 601, + RIGHT_OP = 602, + INC_OP = 603, + DEC_OP = 604, + LE_OP = 605, + GE_OP = 606, + EQ_OP = 607, + NE_OP = 608, + AND_OP = 609, + OR_OP = 610, + XOR_OP = 611, + MUL_ASSIGN = 612, + DIV_ASSIGN = 613, + ADD_ASSIGN = 614, + MOD_ASSIGN = 615, + LEFT_ASSIGN = 616, + RIGHT_ASSIGN = 617, + AND_ASSIGN = 618, + XOR_ASSIGN = 619, + OR_ASSIGN = 620, + SUB_ASSIGN = 621, + LEFT_PAREN = 622, + RIGHT_PAREN = 623, + LEFT_BRACKET = 624, + RIGHT_BRACKET = 625, + LEFT_BRACE = 626, + RIGHT_BRACE = 627, + DOT = 628, + COMMA = 629, + COLON = 630, + EQUAL = 631, + SEMICOLON = 632, + BANG = 633, + DASH = 634, + TILDE = 635, + PLUS = 636, + STAR = 637, + SLASH = 638, + PERCENT = 639, + LEFT_ANGLE = 640, + RIGHT_ANGLE = 641, + VERTICAL_BAR = 642, + CARET = 643, + AMPERSAND = 644, + QUESTION = 645, + INVARIANT = 646, + PRECISE = 647, + HIGH_PRECISION = 648, + MEDIUM_PRECISION = 649, + LOW_PRECISION = 650, + PRECISION = 651, + PACKED = 652, + RESOURCE = 653, + SUPERP = 654 }; #endif @@ -560,7 +563,7 @@ union YYSTYPE }; } interm; -#line 564 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355 */ +#line 567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355 */ }; typedef union YYSTYPE YYSTYPE; @@ -591,7 +594,7 @@ int yyparse (glslang::TParseContext* pParseContext); extern int yylex(YYSTYPE*, TParseContext&); -#line 595 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358 */ +#line 598 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358 */ #ifdef short # undef short @@ -831,23 +834,23 @@ union yyalloc #endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ -#define YYFINAL 372 +#define YYFINAL 375 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 9087 +#define YYLAST 9156 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 397 +#define YYNTOKENS 400 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 107 /* YYNRULES -- Number of rules. */ -#define YYNRULES 562 +#define YYNRULES 565 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 703 +#define YYNSTATES 706 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 651 +#define YYMAXUTOK 654 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) @@ -921,7 +924,7 @@ static const yytype_uint16 yytranslate[] = 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396 + 395, 396, 397, 398, 399 }; #if YYDEBUG @@ -941,50 +944,50 @@ static const yytype_uint16 yyrline[] = 819, 824, 833, 833, 844, 848, 855, 862, 865, 872, 880, 900, 923, 938, 963, 974, 984, 994, 1004, 1013, 1016, 1020, 1024, 1029, 1037, 1042, 1047, 1052, 1057, 1066, - 1077, 1104, 1113, 1120, 1127, 1138, 1147, 1160, 1166, 1169, - 1176, 1180, 1184, 1192, 1201, 1204, 1215, 1218, 1221, 1225, - 1229, 1233, 1237, 1243, 1247, 1259, 1273, 1278, 1284, 1290, - 1297, 1303, 1308, 1313, 1318, 1326, 1330, 1335, 1340, 1345, - 1350, 1355, 1359, 1363, 1367, 1371, 1377, 1386, 1393, 1396, - 1404, 1408, 1417, 1422, 1430, 1434, 1444, 1448, 1452, 1457, - 1462, 1467, 1472, 1476, 1481, 1486, 1491, 1496, 1501, 1506, - 1511, 1516, 1521, 1525, 1530, 1535, 1540, 1546, 1552, 1558, - 1564, 1570, 1576, 1582, 1588, 1594, 1600, 1606, 1612, 1617, - 1622, 1627, 1632, 1637, 1642, 1648, 1654, 1660, 1666, 1672, - 1678, 1684, 1690, 1696, 1702, 1708, 1714, 1720, 1726, 1732, - 1738, 1744, 1750, 1756, 1762, 1768, 1774, 1780, 1786, 1792, - 1798, 1804, 1809, 1814, 1819, 1824, 1829, 1834, 1839, 1844, - 1849, 1854, 1859, 1864, 1870, 1876, 1882, 1888, 1894, 1900, - 1906, 1912, 1918, 1924, 1930, 1936, 1942, 1948, 1954, 1960, - 1966, 1972, 1978, 1984, 1990, 1996, 2002, 2008, 2014, 2020, - 2026, 2032, 2038, 2044, 2050, 2056, 2062, 2068, 2074, 2080, - 2086, 2092, 2098, 2104, 2110, 2116, 2122, 2128, 2134, 2140, - 2146, 2152, 2157, 2162, 2167, 2172, 2177, 2182, 2187, 2192, - 2197, 2202, 2207, 2212, 2217, 2222, 2230, 2238, 2246, 2254, - 2262, 2270, 2278, 2286, 2294, 2302, 2310, 2318, 2326, 2331, - 2336, 2341, 2346, 2351, 2356, 2361, 2366, 2371, 2376, 2381, - 2386, 2391, 2396, 2401, 2406, 2414, 2422, 2427, 2432, 2437, - 2445, 2450, 2455, 2460, 2468, 2473, 2478, 2483, 2491, 2496, - 2501, 2506, 2511, 2516, 2524, 2529, 2537, 2542, 2550, 2555, - 2563, 2568, 2576, 2581, 2589, 2594, 2602, 2607, 2612, 2617, - 2622, 2627, 2632, 2637, 2642, 2647, 2652, 2657, 2662, 2667, - 2672, 2677, 2685, 2690, 2695, 2700, 2708, 2713, 2718, 2723, - 2731, 2736, 2741, 2746, 2754, 2759, 2764, 2769, 2777, 2782, - 2787, 2792, 2800, 2805, 2810, 2815, 2823, 2828, 2833, 2838, - 2846, 2851, 2856, 2861, 2869, 2874, 2879, 2884, 2892, 2897, - 2902, 2907, 2915, 2920, 2925, 2930, 2938, 2943, 2948, 2953, - 2961, 2966, 2971, 2976, 2984, 2989, 2994, 2999, 3007, 3012, - 3017, 3023, 3029, 3035, 3044, 3053, 3059, 3065, 3071, 3077, - 3082, 3098, 3103, 3108, 3116, 3116, 3127, 3127, 3137, 3140, - 3153, 3175, 3202, 3206, 3212, 3217, 3228, 3231, 3237, 3246, - 3249, 3255, 3259, 3260, 3266, 3267, 3268, 3269, 3270, 3271, - 3272, 3276, 3277, 3281, 3277, 3293, 3294, 3298, 3298, 3305, - 3305, 3319, 3322, 3330, 3338, 3349, 3350, 3354, 3357, 3363, - 3370, 3374, 3382, 3386, 3399, 3402, 3408, 3408, 3428, 3431, - 3437, 3449, 3461, 3464, 3470, 3470, 3485, 3485, 3501, 3501, - 3522, 3525, 3531, 3534, 3540, 3544, 3551, 3556, 3561, 3568, - 3571, 3580, 3584, 3593, 3596, 3599, 3607, 3607, 3629, 3635, - 3638, 3643, 3646 + 1077, 1104, 1113, 1120, 1127, 1138, 1147, 1157, 1165, 1173, + 1184, 1190, 1193, 1200, 1204, 1208, 1216, 1225, 1228, 1239, + 1242, 1245, 1249, 1253, 1257, 1261, 1267, 1271, 1283, 1297, + 1302, 1308, 1314, 1321, 1327, 1332, 1337, 1342, 1354, 1358, + 1363, 1368, 1373, 1378, 1383, 1387, 1391, 1395, 1399, 1405, + 1414, 1421, 1424, 1432, 1436, 1445, 1450, 1458, 1462, 1472, + 1476, 1480, 1485, 1490, 1495, 1500, 1504, 1509, 1514, 1519, + 1524, 1529, 1534, 1539, 1544, 1549, 1553, 1558, 1563, 1568, + 1574, 1580, 1586, 1592, 1598, 1604, 1610, 1616, 1622, 1628, + 1634, 1640, 1645, 1650, 1655, 1660, 1665, 1670, 1676, 1682, + 1688, 1694, 1700, 1706, 1712, 1718, 1724, 1730, 1736, 1742, + 1748, 1754, 1760, 1766, 1772, 1778, 1784, 1790, 1796, 1802, + 1808, 1814, 1820, 1826, 1832, 1837, 1842, 1847, 1852, 1857, + 1862, 1867, 1872, 1877, 1882, 1887, 1892, 1898, 1904, 1910, + 1916, 1922, 1928, 1934, 1940, 1946, 1952, 1958, 1964, 1970, + 1976, 1982, 1988, 1994, 2000, 2006, 2012, 2018, 2024, 2030, + 2036, 2042, 2048, 2054, 2060, 2066, 2072, 2078, 2084, 2090, + 2096, 2102, 2108, 2114, 2120, 2126, 2132, 2138, 2144, 2150, + 2156, 2162, 2168, 2174, 2180, 2185, 2190, 2195, 2200, 2205, + 2210, 2215, 2220, 2225, 2230, 2235, 2240, 2245, 2250, 2258, + 2266, 2274, 2282, 2290, 2298, 2306, 2314, 2322, 2330, 2338, + 2346, 2354, 2359, 2364, 2369, 2374, 2379, 2384, 2389, 2394, + 2399, 2404, 2409, 2414, 2419, 2424, 2429, 2434, 2442, 2450, + 2455, 2460, 2465, 2473, 2478, 2483, 2488, 2496, 2501, 2506, + 2511, 2519, 2524, 2529, 2534, 2539, 2544, 2552, 2557, 2565, + 2570, 2578, 2583, 2591, 2596, 2604, 2609, 2617, 2622, 2630, + 2635, 2640, 2645, 2650, 2655, 2660, 2665, 2670, 2675, 2680, + 2685, 2690, 2695, 2700, 2705, 2713, 2718, 2723, 2728, 2736, + 2741, 2746, 2751, 2759, 2764, 2769, 2774, 2782, 2787, 2792, + 2797, 2805, 2810, 2815, 2820, 2828, 2833, 2838, 2843, 2851, + 2856, 2861, 2866, 2874, 2879, 2884, 2889, 2897, 2902, 2907, + 2912, 2920, 2925, 2930, 2935, 2943, 2948, 2953, 2958, 2966, + 2971, 2976, 2981, 2989, 2994, 2999, 3004, 3012, 3017, 3022, + 3027, 3035, 3040, 3045, 3051, 3057, 3063, 3072, 3081, 3087, + 3093, 3099, 3105, 3110, 3126, 3131, 3136, 3144, 3144, 3155, + 3155, 3165, 3168, 3181, 3203, 3230, 3234, 3240, 3245, 3256, + 3259, 3265, 3274, 3277, 3283, 3287, 3288, 3294, 3295, 3296, + 3297, 3298, 3299, 3300, 3304, 3305, 3309, 3305, 3321, 3322, + 3326, 3326, 3333, 3333, 3347, 3350, 3358, 3366, 3377, 3378, + 3382, 3385, 3391, 3398, 3402, 3410, 3414, 3427, 3430, 3436, + 3436, 3456, 3459, 3465, 3477, 3489, 3492, 3498, 3498, 3513, + 3513, 3529, 3529, 3550, 3553, 3559, 3562, 3568, 3572, 3579, + 3584, 3589, 3596, 3599, 3608, 3612, 3621, 3624, 3627, 3635, + 3635, 3657, 3663, 3666, 3671, 3674 }; #endif @@ -1012,16 +1015,17 @@ static const char *const yytname[] = "F16MAT2", "F16MAT3", "F16MAT4", "F32VEC2", "F32VEC3", "F32VEC4", "F32MAT2", "F32MAT3", "F32MAT4", "F64VEC2", "F64VEC3", "F64VEC4", "F64MAT2", "F64MAT3", "F64MAT4", "NOPERSPECTIVE", "FLAT", "SMOOTH", - "LAYOUT", "EXPLICITINTERPAMD", "PERVERTEXNV", "MAT2X2", "MAT2X3", - "MAT2X4", "MAT3X2", "MAT3X3", "MAT3X4", "MAT4X2", "MAT4X3", "MAT4X4", - "DMAT2X2", "DMAT2X3", "DMAT2X4", "DMAT3X2", "DMAT3X3", "DMAT3X4", - "DMAT4X2", "DMAT4X3", "DMAT4X4", "F16MAT2X2", "F16MAT2X3", "F16MAT2X4", - "F16MAT3X2", "F16MAT3X3", "F16MAT3X4", "F16MAT4X2", "F16MAT4X3", - "F16MAT4X4", "F32MAT2X2", "F32MAT2X3", "F32MAT2X4", "F32MAT3X2", - "F32MAT3X3", "F32MAT3X4", "F32MAT4X2", "F32MAT4X3", "F32MAT4X4", - "F64MAT2X2", "F64MAT2X3", "F64MAT2X4", "F64MAT3X2", "F64MAT3X3", - "F64MAT3X4", "F64MAT4X2", "F64MAT4X3", "F64MAT4X4", "ATOMIC_UINT", - "SAMPLER1D", "SAMPLER2D", "SAMPLER3D", "SAMPLERCUBE", "SAMPLER1DSHADOW", + "LAYOUT", "EXPLICITINTERPAMD", "PERVERTEXNV", "PERPRIMITIVENV", + "PERVIEWNV", "PERTASKNV", "MAT2X2", "MAT2X3", "MAT2X4", "MAT3X2", + "MAT3X3", "MAT3X4", "MAT4X2", "MAT4X3", "MAT4X4", "DMAT2X2", "DMAT2X3", + "DMAT2X4", "DMAT3X2", "DMAT3X3", "DMAT3X4", "DMAT4X2", "DMAT4X3", + "DMAT4X4", "F16MAT2X2", "F16MAT2X3", "F16MAT2X4", "F16MAT3X2", + "F16MAT3X3", "F16MAT3X4", "F16MAT4X2", "F16MAT4X3", "F16MAT4X4", + "F32MAT2X2", "F32MAT2X3", "F32MAT2X4", "F32MAT3X2", "F32MAT3X3", + "F32MAT3X4", "F32MAT4X2", "F32MAT4X3", "F32MAT4X4", "F64MAT2X2", + "F64MAT2X3", "F64MAT2X4", "F64MAT3X2", "F64MAT3X3", "F64MAT3X4", + "F64MAT4X2", "F64MAT4X3", "F64MAT4X4", "ATOMIC_UINT", "SAMPLER1D", + "SAMPLER2D", "SAMPLER3D", "SAMPLERCUBE", "SAMPLER1DSHADOW", "SAMPLER2DSHADOW", "SAMPLERCUBESHADOW", "SAMPLER1DARRAY", "SAMPLER2DARRAY", "SAMPLER1DARRAYSHADOW", "SAMPLER2DARRAYSHADOW", "ISAMPLER1D", "ISAMPLER2D", "ISAMPLER3D", "ISAMPLERCUBE", @@ -1161,16 +1165,16 @@ static const yytype_uint16 yytoknum[] = 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, - 645, 646, 647, 648, 649, 650, 651 + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 }; # endif -#define YYPACT_NINF -646 +#define YYPACT_NINF -641 #define yypact_value_is_default(Yystate) \ - (!!((Yystate) == (-646))) + (!!((Yystate) == (-641))) -#define YYTABLE_NINF -508 +#define YYTABLE_NINF -511 #define yytable_value_is_error(Yytable_value) \ 0 @@ -1179,77 +1183,77 @@ static const yytype_uint16 yytoknum[] = STATE-NUM. */ static const yytype_int16 yypact[] = { - 3439, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -315, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -298, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -646, -311, -646, -646, -646, -646, -646, -646, - -646, -646, -355, -646, -312, -348, -284, -307, 5780, -267, - -646, -220, -646, -646, -646, -646, 4220, -646, -646, -646, - -646, -242, -646, -646, 702, -646, -646, -203, -70, -232, - -646, 8757, -344, -646, -646, -217, -646, 5780, -646, -646, - -646, 5780, -146, -144, -646, -303, -288, -646, -646, -646, - 6513, -179, -646, -646, -646, -286, -646, -180, -277, -646, - -646, 5780, -178, -646, -341, 1093, -646, -646, -646, -646, - -242, -301, -646, 6887, -299, -646, -132, -646, -263, -646, - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, 8009, 8009, 8009, -646, -646, -646, -646, -646, - -646, -646, -293, -646, -646, -646, -167, -273, 8383, -165, - -646, 8009, -231, -300, -230, -328, -196, -186, -184, -182, - -147, -148, -329, -161, -646, -646, 7261, -646, -122, 8009, - -646, -70, 5780, 5780, -121, 4610, -646, -646, -646, -164, - -163, -646, -155, -152, -160, 7635, -151, 8009, -157, -145, - -150, -143, -646, -646, -216, -646, -646, -251, -646, -348, - -142, -141, -646, -646, -646, -646, 1484, -646, -646, -646, - -646, -646, -646, -646, -646, -646, -17, -179, 6887, -291, - 6887, -646, -646, 6887, 5780, -646, -112, -646, -646, -646, - -270, -646, -646, 8009, -111, -646, -646, 8009, -140, -646, - -646, -646, 8009, 8009, 8009, 8009, 8009, 8009, 8009, 8009, - 8009, 8009, 8009, 8009, 8009, 8009, 8009, 8009, 8009, 8009, - 8009, -646, -646, -646, -139, -646, -646, -646, -646, 5000, - -121, -242, -249, -646, -646, -646, -646, -646, 1875, -646, - 8009, -646, -646, -243, 8009, -213, -646, -646, -108, -646, - 1875, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, 8009, 8009, -646, -646, -646, -646, -646, -646, - -646, 6887, -646, -324, -646, 5390, -646, -646, -138, -137, - -646, -646, -646, -646, -646, -231, -231, -300, -300, -230, - -230, -230, -230, -328, -328, -196, -186, -184, -182, -147, - -148, 8009, -646, -646, -239, -179, -121, -646, -101, 3048, - -269, -646, -268, -646, 3830, -134, -323, -646, 1875, -646, - -646, -646, -646, 6139, -646, -646, -190, -646, -646, -133, - -646, -646, 3830, -135, -646, -137, -94, 5780, -129, 8009, - -130, -108, -131, -646, -646, 8009, 8009, -646, -128, -126, - 216, -125, 2657, -646, -124, -123, 2266, -118, -646, -646, - -646, -646, -266, 8009, 2266, -135, -646, -646, 1875, 6887, - -646, -646, -646, -646, -120, -137, -646, -646, 1875, -127, - -646, -646, -646 + 3463, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -313, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -262, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, -641, -310, -641, -641, -641, + -641, -641, -641, -641, -641, -269, -641, -311, -351, -331, + -295, 5822, -282, -641, -235, -641, -641, -641, -641, 4250, + -641, -641, -641, -641, -229, -641, -641, 705, -641, -641, + -177, -69, -214, -641, 8823, -336, -641, -641, -208, -641, + 5822, -641, -641, -641, 5822, -164, -163, -641, -333, -299, + -641, -641, -641, 6561, -199, -641, -641, -641, -301, -641, + -205, -300, -641, -641, 5822, -204, -641, -329, 1099, -641, + -641, -641, -641, -229, -319, -641, 6938, -307, -641, -160, + -641, -271, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, 8069, 8069, 8069, -641, -641, + -641, -641, -641, -641, -641, -318, -641, -641, -641, -194, + -292, 8446, -192, -641, 8069, -247, -288, -218, -327, -221, + -213, -211, -209, -174, -175, -330, -188, -641, -641, 7315, + -641, -149, 8069, -641, -69, 5822, 5822, -148, 4643, -641, + -641, -641, -191, -190, -641, -182, -179, -187, 7692, -178, + 8069, -183, -173, -176, -172, -641, -641, -212, -641, -641, + -270, -641, -351, -171, -170, -641, -641, -641, -641, 1493, + -641, -641, -641, -641, -641, -641, -641, -641, -641, -19, + -199, 6938, -306, 6938, -641, -641, 6938, 5822, -641, -131, + -641, -641, -641, -291, -641, -641, 8069, -130, -641, -641, + 8069, -165, -641, -641, -641, 8069, 8069, 8069, 8069, 8069, + 8069, 8069, 8069, 8069, 8069, 8069, 8069, 8069, 8069, 8069, + 8069, 8069, 8069, 8069, -641, -641, -641, -166, -641, -641, + -641, -641, 5036, -148, -229, -264, -641, -641, -641, -641, + -641, 1887, -641, 8069, -641, -641, -259, 8069, -236, -641, + -641, -127, -641, 1887, -641, -641, -641, -641, -641, -641, + -641, -641, -641, -641, -641, 8069, 8069, -641, -641, -641, + -641, -641, -641, -641, 6938, -641, -263, -641, 5429, -641, + -641, -162, -159, -641, -641, -641, -641, -641, -247, -247, + -288, -288, -218, -218, -218, -218, -327, -327, -221, -213, + -211, -209, -174, -175, 8069, -641, -641, -257, -199, -148, + -641, -122, 3069, -287, -641, -284, -641, 3857, -157, -332, + -641, 1887, -641, -641, -641, -641, 6184, -641, -641, -232, + -641, -641, -156, -641, -641, 3857, -155, -641, -159, -120, + 5822, -154, 8069, -153, -127, -152, -641, -641, 8069, 8069, + -641, -158, -150, 196, -145, 2675, -641, -144, -147, 2281, + -146, -641, -641, -641, -641, -280, 8069, 2281, -155, -641, + -641, 1887, 6938, -641, -641, -641, -641, -126, -159, -641, + -641, 1887, -142, -641, -641, -641 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -1257,109 +1261,109 @@ static const yytype_int16 yypact[] = means the default is an error. */ static const yytype_uint16 yydefact[] = { - 0, 154, 155, 189, 187, 190, 188, 191, 153, 202, - 192, 193, 200, 201, 198, 199, 196, 197, 194, 195, - 175, 218, 219, 220, 221, 222, 223, 236, 237, 238, - 233, 234, 235, 248, 249, 250, 230, 231, 232, 245, - 246, 247, 227, 228, 229, 242, 243, 244, 224, 225, - 226, 239, 240, 241, 203, 204, 205, 251, 252, 253, - 159, 157, 158, 156, 162, 160, 161, 163, 164, 177, - 165, 171, 172, 173, 174, 166, 167, 168, 169, 170, - 206, 207, 208, 263, 264, 265, 209, 210, 211, 275, - 276, 277, 212, 213, 214, 287, 288, 289, 215, 216, - 217, 299, 300, 301, 134, 133, 132, 0, 135, 136, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 302, 303, 304, 305, + 0, 157, 158, 192, 190, 193, 191, 194, 156, 205, + 195, 196, 203, 204, 201, 202, 199, 200, 197, 198, + 178, 221, 222, 223, 224, 225, 226, 239, 240, 241, + 236, 237, 238, 251, 252, 253, 233, 234, 235, 248, + 249, 250, 230, 231, 232, 245, 246, 247, 227, 228, + 229, 242, 243, 244, 206, 207, 208, 254, 255, 256, + 162, 160, 161, 159, 165, 163, 164, 166, 167, 180, + 168, 174, 175, 176, 177, 169, 170, 171, 172, 173, + 209, 210, 211, 266, 267, 268, 212, 213, 214, 278, + 279, 280, 215, 216, 217, 290, 291, 292, 218, 219, + 220, 302, 303, 304, 134, 133, 132, 0, 135, 136, + 137, 138, 139, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 293, 294, 295, 296, 297, 298, 299, 300, 301, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 338, 339, 340, - 341, 342, 343, 345, 346, 347, 348, 349, 350, 352, - 353, 356, 357, 358, 360, 361, 323, 324, 344, 351, - 362, 364, 365, 366, 368, 369, 460, 325, 326, 327, - 354, 328, 332, 333, 336, 359, 363, 367, 329, 330, - 334, 335, 355, 331, 337, 370, 371, 372, 374, 376, - 378, 380, 382, 386, 387, 388, 389, 390, 391, 393, - 394, 395, 396, 397, 398, 400, 402, 403, 404, 406, - 407, 384, 392, 399, 408, 410, 411, 412, 414, 415, - 373, 375, 377, 401, 379, 381, 383, 385, 405, 409, - 413, 461, 462, 465, 466, 467, 468, 463, 464, 416, - 418, 419, 420, 422, 423, 424, 426, 427, 428, 430, - 431, 432, 434, 435, 436, 438, 439, 440, 442, 443, - 444, 446, 447, 448, 450, 451, 452, 454, 455, 456, - 458, 459, 417, 421, 425, 429, 433, 441, 445, 449, - 437, 453, 457, 0, 186, 470, 555, 131, 143, 471, - 472, 473, 0, 554, 0, 556, 0, 108, 107, 0, - 119, 124, 150, 149, 147, 151, 0, 144, 146, 152, - 129, 180, 148, 469, 0, 551, 553, 0, 0, 0, - 476, 0, 0, 96, 93, 0, 106, 0, 115, 109, - 117, 0, 118, 0, 94, 125, 0, 99, 145, 130, - 0, 181, 1, 552, 178, 0, 142, 140, 0, 138, - 474, 0, 0, 97, 0, 0, 557, 110, 114, 116, - 112, 120, 111, 0, 126, 102, 0, 100, 0, 2, - 12, 13, 10, 11, 4, 5, 6, 7, 8, 9, - 15, 14, 0, 0, 0, 182, 42, 41, 43, 40, - 3, 17, 36, 19, 24, 25, 0, 0, 29, 0, - 44, 0, 48, 51, 54, 59, 62, 64, 66, 68, - 70, 72, 74, 0, 35, 33, 0, 176, 0, 0, - 137, 0, 0, 0, 0, 0, 478, 95, 98, 0, - 0, 536, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 502, 511, 515, 44, 77, 90, 0, 491, 0, - 152, 129, 494, 513, 493, 492, 0, 495, 496, 517, - 497, 524, 498, 499, 532, 500, 0, 113, 0, 121, - 0, 486, 128, 0, 0, 104, 0, 101, 37, 38, - 0, 21, 22, 0, 0, 27, 26, 0, 186, 30, - 32, 39, 0, 0, 0, 0, 0, 0, 0, 0, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 341, 342, 343, 344, 345, 346, 348, 349, 350, 351, + 352, 353, 355, 356, 359, 360, 361, 363, 364, 326, + 327, 347, 354, 365, 367, 368, 369, 371, 372, 463, + 328, 329, 330, 357, 331, 335, 336, 339, 362, 366, + 370, 332, 333, 337, 338, 358, 334, 340, 373, 374, + 375, 377, 379, 381, 383, 385, 389, 390, 391, 392, + 393, 394, 396, 397, 398, 399, 400, 401, 403, 405, + 406, 407, 409, 410, 387, 395, 402, 411, 413, 414, + 415, 417, 418, 376, 378, 380, 404, 382, 384, 386, + 388, 408, 412, 416, 464, 465, 468, 469, 470, 471, + 466, 467, 419, 421, 422, 423, 425, 426, 427, 429, + 430, 431, 433, 434, 435, 437, 438, 439, 441, 442, + 443, 445, 446, 447, 449, 450, 451, 453, 454, 455, + 457, 458, 459, 461, 462, 420, 424, 428, 432, 436, + 444, 448, 452, 440, 456, 460, 0, 189, 473, 558, + 131, 146, 474, 475, 476, 0, 557, 0, 559, 0, + 108, 107, 0, 119, 124, 153, 152, 150, 154, 0, + 147, 149, 155, 129, 183, 151, 472, 0, 554, 556, + 0, 0, 0, 479, 0, 0, 96, 93, 0, 106, + 0, 115, 109, 117, 0, 118, 0, 94, 125, 0, + 99, 148, 130, 0, 184, 1, 555, 181, 0, 145, + 143, 0, 141, 477, 0, 0, 97, 0, 0, 560, + 110, 114, 116, 112, 120, 111, 0, 126, 102, 0, + 100, 0, 2, 12, 13, 10, 11, 4, 5, 6, + 7, 8, 9, 15, 14, 0, 0, 0, 185, 42, + 41, 43, 40, 3, 17, 36, 19, 24, 25, 0, + 0, 29, 0, 44, 0, 48, 51, 54, 59, 62, + 64, 66, 68, 70, 72, 74, 0, 35, 33, 0, + 179, 0, 0, 140, 0, 0, 0, 0, 0, 481, + 95, 98, 0, 0, 539, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 505, 514, 518, 44, 77, 90, + 0, 494, 0, 155, 129, 497, 516, 496, 495, 0, + 498, 499, 520, 500, 527, 501, 502, 535, 503, 0, + 113, 0, 121, 0, 489, 128, 0, 0, 104, 0, + 101, 37, 38, 0, 21, 22, 0, 0, 27, 26, + 0, 189, 30, 32, 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 75, 183, 184, 0, 179, 92, 141, 139, 0, - 0, 484, 0, 482, 477, 479, 547, 546, 0, 538, - 0, 550, 548, 0, 0, 0, 531, 534, 0, 501, - 0, 80, 81, 83, 82, 85, 86, 87, 88, 89, - 84, 79, 0, 0, 516, 512, 514, 518, 525, 533, - 123, 0, 489, 0, 127, 0, 105, 16, 0, 23, - 20, 31, 45, 46, 47, 50, 49, 52, 53, 57, - 58, 55, 56, 60, 61, 63, 65, 67, 69, 71, - 73, 0, 185, 475, 0, 485, 0, 480, 0, 0, - 0, 549, 0, 530, 0, 561, 0, 559, 503, 78, - 91, 122, 487, 0, 103, 18, 0, 481, 483, 0, - 541, 540, 543, 509, 526, 522, 0, 0, 0, 0, - 0, 0, 0, 488, 490, 0, 0, 542, 0, 0, - 521, 0, 0, 519, 0, 0, 0, 0, 558, 560, - 504, 76, 0, 544, 0, 509, 508, 510, 528, 0, - 506, 535, 505, 562, 0, 545, 539, 520, 529, 0, - 523, 537, 527 + 0, 0, 0, 0, 75, 186, 187, 0, 182, 92, + 144, 142, 0, 0, 487, 0, 485, 480, 482, 550, + 549, 0, 541, 0, 553, 551, 0, 0, 0, 534, + 537, 0, 504, 0, 80, 81, 83, 82, 85, 86, + 87, 88, 89, 84, 79, 0, 0, 519, 515, 517, + 521, 528, 536, 123, 0, 492, 0, 127, 0, 105, + 16, 0, 23, 20, 31, 45, 46, 47, 50, 49, + 52, 53, 57, 58, 55, 56, 60, 61, 63, 65, + 67, 69, 71, 73, 0, 188, 478, 0, 488, 0, + 483, 0, 0, 0, 552, 0, 533, 0, 564, 0, + 562, 506, 78, 91, 122, 490, 0, 103, 18, 0, + 484, 486, 0, 544, 543, 546, 512, 529, 525, 0, + 0, 0, 0, 0, 0, 0, 491, 493, 0, 0, + 545, 0, 0, 524, 0, 0, 522, 0, 0, 0, + 0, 561, 563, 507, 76, 0, 547, 0, 512, 511, + 513, 531, 0, 509, 538, 508, 565, 0, 548, 542, + 523, 532, 0, 526, 540, 530 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -646, -646, -646, -646, -646, -646, -646, -646, -646, -646, - -646, -646, -362, -646, -370, -338, -413, -342, -287, -285, - -281, -289, -282, -280, -646, -356, -646, -388, -646, -376, - -407, 1, -646, -646, -646, 2, -646, -646, -646, -100, - -104, -99, -646, -646, -610, -646, -646, -646, -646, -188, - -646, -325, -332, -646, 6, -646, 0, -331, -646, -58, - -646, -646, -646, -436, -443, -283, -361, -457, -646, -363, - -458, -645, -403, -646, -646, -415, -414, -646, -646, -83, - -555, -354, -646, -223, -646, -378, -646, -218, -646, -646, - -646, -646, -215, -646, -646, -646, -646, -646, -646, -646, - -646, -65, -646, -646, -646, -646, -381 + -641, -641, -641, -641, -641, -641, -641, -641, -641, -641, + -641, -641, -293, -641, -464, -369, -433, -370, -315, -308, + -312, -286, -289, -285, -641, -363, -641, -387, -641, -372, + -408, 1, -641, -641, -641, 2, -641, -641, -641, -108, + -103, -104, -641, -641, -609, -641, -641, -641, -641, -193, + -641, -328, -335, -641, 6, -641, 0, -341, -641, -63, + -641, -641, -641, -436, -440, -281, -365, -486, -641, -366, + -476, -640, -407, -641, -641, -419, -417, -641, -641, -89, + -557, -359, -641, -225, -641, -380, -641, -223, -641, -641, + -641, -641, -222, -641, -641, -641, -641, -641, -641, -641, + -641, -68, -641, -641, -641, -641, -386 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 420, 421, 422, 598, 423, 424, 425, 426, 427, - 428, 429, 474, 431, 432, 433, 434, 435, 436, 437, - 438, 439, 440, 441, 442, 475, 621, 476, 582, 477, - 547, 478, 324, 504, 398, 479, 326, 327, 328, 358, - 359, 360, 329, 330, 331, 332, 333, 334, 378, 379, - 335, 336, 337, 338, 444, 375, 445, 371, 341, 342, - 343, 452, 381, 455, 456, 552, 553, 502, 593, 482, - 483, 484, 485, 570, 662, 691, 670, 671, 672, 692, - 486, 487, 488, 489, 673, 658, 490, 491, 674, 699, - 492, 493, 494, 634, 558, 629, 652, 668, 669, 495, - 344, 345, 346, 355, 496, 636, 637 + -1, 423, 424, 425, 601, 426, 427, 428, 429, 430, + 431, 432, 477, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 478, 624, 479, 585, 480, + 550, 481, 327, 507, 401, 482, 329, 330, 331, 361, + 362, 363, 332, 333, 334, 335, 336, 337, 381, 382, + 338, 339, 340, 341, 447, 378, 448, 374, 344, 345, + 346, 455, 384, 458, 459, 555, 556, 505, 596, 485, + 486, 487, 488, 573, 665, 694, 673, 674, 675, 695, + 489, 490, 491, 492, 676, 661, 493, 494, 677, 702, + 495, 496, 497, 637, 561, 632, 655, 671, 672, 498, + 347, 348, 349, 358, 499, 639, 640 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -1367,77 +1371,589 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = {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static const yytype_int16 yytable[] = 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 0, 0, 315, 0, 0, 0, 0, 0, 0, 0, + 315, 316, 317, 0, 0, 318, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 316, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 317, 318, 319, 320, 321, 322, 1, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 459, 460, 461, 0, 462, - 463, 464, 465, 466, 467, 468, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 469, 399, 315, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 0, 0, 412, 413, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 414, 0, 470, - 0, 471, 472, 0, 0, 0, 0, 473, 416, 417, - 418, 419, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 317, 318, 319, 320, 321, 322, 1, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 459, 460, 461, 0, - 462, 463, 464, 465, 466, 467, 468, 20, 21, 22, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 4, 5, 6, 7, 0, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 0, 0, 0, 0, + 0, 0, 0, 320, 321, 322, 323, 324, 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, + 53, 54, 55, 56, 57, 58, 59, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 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, + 103, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, @@ -1548,26 +2022,100 @@ static const yytype_int16 yytable[] = 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 469, 399, 315, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 0, 0, 412, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 414, 0, - 470, 0, 471, 585, 0, 0, 0, 0, 473, 416, - 417, 418, 419, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 317, 318, 319, 320, 321, 322, 1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 459, 460, 461, - 0, 462, 463, 464, 465, 466, 467, 468, 20, 21, + 313, 314, 315, 316, 317, 0, 402, 318, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 0, 0, 415, 416, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 417, 0, 0, 0, 503, 666, 0, 0, 0, + 0, 0, 419, 420, 421, 422, 3, 4, 5, 6, + 7, 0, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 0, 402, 318, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, 0, 0, 415, + 416, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 417, 0, + 0, 418, 0, 0, 0, 0, 0, 0, 0, 419, + 420, 421, 422, 3, 4, 5, 6, 7, 0, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 0, + 402, 318, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 0, 0, 415, 416, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 417, 0, 0, 0, 503, + 0, 0, 0, 0, 0, 0, 419, 420, 421, 422, + 3, 4, 5, 6, 7, 0, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 52, 53, 54, 55, 56, 57, 58, 59, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 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, + 102, 103, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 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, @@ -1587,19 +2135,277 @@ static const yytype_int16 yytable[] = 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 469, 399, 315, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 0, 0, - 412, 413, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 414, - 0, 470, 0, 471, 0, 0, 0, 0, 0, 473, - 416, 417, 418, 419, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 317, 318, 319, 320, 321, 322, 1, - 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 459, 460, - 461, 0, 462, 463, 464, 465, 466, 467, 468, 20, + 312, 313, 314, 315, 316, 317, 0, 402, 318, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, 0, 0, 415, 416, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 417, 0, 0, 546, 0, 0, 0, 0, + 0, 0, 0, 419, 420, 421, 422, 3, 4, 5, + 6, 7, 0, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 69, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 0, 402, 318, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 0, 0, + 415, 416, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 417, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 565, + 419, 420, 421, 422, 3, 4, 5, 6, 7, 0, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 0, 402, 318, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 0, 0, 415, 416, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 417, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 419, 420, 421, + 422, 3, 4, 5, 6, 7, 0, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 69, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 521, 0, 402, 318, + 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 0, 0, 415, 416, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 417, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 419, 420, 421, 422, 3, 4, + 5, 6, 7, 0, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 0, 0, 318 +}; + +static const yytype_int16 yycheck[] = +{ + 0, 0, 0, 331, 339, 24, 0, 26, 27, 396, + 373, 30, 81, 489, 355, 501, 573, 503, 458, 455, + 506, 332, 332, 350, 351, 355, 377, 368, 637, 364, + 348, 349, 360, 369, 367, 675, 369, 368, 370, 679, + 369, 377, 374, 376, 431, 417, 655, 687, 377, 367, + 369, 369, 393, 394, 367, 373, 384, 376, 385, 386, + 390, 371, 369, 369, 528, 529, 377, 368, 368, 376, + 376, 507, 371, 374, 374, 374, 368, 368, 377, 374, + 373, 368, 374, 374, 368, 561, 449, 374, 368, 452, + 374, 379, 374, 381, 374, 377, 468, 332, 470, 532, + 533, 534, 535, 374, 374, 367, 377, 377, 594, 372, + 374, 374, 552, 377, 501, 374, 503, 374, 377, 506, + 377, 456, 415, 416, 393, 394, 395, 455, 346, 347, + 458, 352, 353, 520, 691, 382, 383, 384, 374, 375, + 369, 434, 374, 375, 516, 357, 358, 359, 360, 361, + 362, 363, 364, 365, 366, 332, 449, 371, 598, 452, + 646, 530, 531, 371, 376, 641, 536, 537, 332, 332, + 369, 376, 332, 377, 368, 367, 389, 388, 387, 507, + 354, 356, 370, 332, 332, 367, 377, 377, 367, 367, + 377, 563, 375, 369, 367, 567, 367, 367, 585, 586, + 372, 332, 332, 368, 370, 332, 692, 594, 370, 331, + 367, 367, 332, 554, 368, 374, 371, 370, 368, 377, + 372, 25, 368, 538, 552, 701, 371, 371, 540, 376, + 372, 539, 525, 526, 527, 528, 529, 530, 531, 532, + 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, + 543, 377, 624, 542, 662, 541, 364, 360, 543, 646, + 364, 454, 325, 332, 629, 637, 632, 674, 687, 358, + 598, 688, 553, 632, 499, 655, 499, 499, 664, 347, + -1, 668, -1, 655, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 669, -1, 662, + -1, -1, -1, -1, -1, 692, -1, -1, -1, 637, + -1, -1, 331, -1, 686, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 660, -1, 655, -1, -1, + -1, 331, -1, -1, -1, -1, -1, 331, -1, 339, + -1, -1, -1, -1, -1, 339, -1, 347, 347, 347, + -1, -1, -1, 347, 354, -1, -1, -1, -1, -1, + 360, -1, -1, -1, 364, -1, 360, -1, -1, 662, + 364, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 384, -1, -1, -1, 388, -1, + 384, -1, -1, -1, 388, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 455, 456, -1, 458, -1, + -1, 455, 456, -1, 458, -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, -1, 489, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 507, -1, -1, + -1, -1, -1, 507, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 552, -1, -1, -1, -1, -1, 552, -1, + -1, 561, -1, -1, -1, -1, -1, 561, -1, -1, + -1, -1, -1, 573, -1, -1, -1, -1, -1, 573, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 598, -1, + -1, -1, -1, -1, 598, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 632, -1, -1, -1, -1, 637, 632, -1, + -1, 641, -1, 637, -1, -1, -1, 641, -1, -1, + -1, -1, -1, -1, -1, 655, -1, -1, -1, -1, + 660, 655, -1, -1, -1, -1, 660, -1, -1, -1, + -1, -1, -1, -1, -1, 675, -1, -1, -1, 679, + -1, 675, -1, -1, -1, 679, -1, 687, -1, -1, + -1, 691, -1, 687, -1, -1, -1, 691, -1, -1, + -1, 701, -1, -1, -1, 0, -1, 701, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, -1, -1, 333, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 377, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 391, 392, 393, 394, + 395, 396, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, -1, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, @@ -1626,770 +2432,15 @@ static const yytype_int16 yytable[] = 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 469, 399, 315, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 0, - 0, 412, 413, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 414, 0, 470, 0, 385, 0, 0, 0, 0, 0, - 473, 416, 417, 418, 419, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 317, 318, 319, 320, 321, 322, - 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 459, - 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 469, 399, 315, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 0, 0, 412, 413, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 414, 0, 470, 0, 0, 0, 0, 0, 0, - 0, 473, 416, 417, 418, 419, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 317, 318, 319, 320, 321, - 322, 1, 2, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, - 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, - 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, - 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 0, 399, 315, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 0, 0, 412, 413, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 414, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 473, 416, 417, 418, 419, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 317, 318, 319, 320, - 321, 322, 1, 2, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 0, 0, 315, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 316, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 317, 318, 319, - 320, 321, 322, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 0, 399, - 315, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 0, 0, 412, 413, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 414, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 416, 417, 418, 419, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 317, 318, - 319, 320, 321, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 0, 366, - 315, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 367, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 317, 318, - 319, 320, 321, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 0, 0, - 315, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 554, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 317, 318, - 319, 320, 321, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 0, 0, - 315, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 623, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 317, 318, - 319, 320, 321, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 0, 0, - 315, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 644, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 317, 318, - 319, 320, 321, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 0, 0, - 315, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3, 4, 5, 6, 7, 0, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 0, 0, 0, 0, 0, 0, 0, 317, 318, - 319, 320, 321, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 0, 0, 0, 0, - 0, 0, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 0, 399, 315, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 0, 0, 412, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 414, 0, 0, 0, 500, 663, 0, - 0, 0, 0, 0, 416, 417, 418, 419, 3, 4, - 5, 6, 7, 0, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 69, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 0, 0, 0, 0, 0, 0, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 0, 399, 315, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 0, 0, 412, 413, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 414, 0, 0, - 415, 0, 0, 0, 0, 0, 0, 0, 416, 417, - 418, 419, 3, 4, 5, 6, 7, 0, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 69, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 0, 0, 0, 0, 0, 0, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 0, 399, 315, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 0, 0, 412, 413, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 414, 0, 0, 0, 500, 0, 0, 0, 0, - 0, 0, 416, 417, 418, 419, 3, 4, 5, 6, - 7, 0, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 0, 0, - 0, 0, 0, 0, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 0, - 399, 315, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 0, 0, 412, 413, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 414, 0, 0, 543, 0, - 0, 0, 0, 0, 0, 0, 416, 417, 418, 419, - 3, 4, 5, 6, 7, 0, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 0, 0, 0, 0, 0, 0, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 0, 399, 315, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 0, 0, - 412, 413, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 414, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 562, - 416, 417, 418, 419, 3, 4, 5, 6, 7, 0, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 0, 0, 0, 0, - 0, 0, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 0, 399, 315, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 0, 0, 412, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 414, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 416, 417, 418, 419, 3, 4, - 5, 6, 7, 0, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 69, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 0, 0, 0, 0, 0, 0, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 518, 0, 399, 315, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 0, 0, 412, 413, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 414, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 416, 417, - 418, 419, 3, 4, 5, 6, 7, 0, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 0, 0, 0, 0, 0, 0, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 0, 0, 315 -}; - -static const yytype_int16 yycheck[] = -{ - 0, 0, 0, 328, 336, 393, 0, 24, 370, 26, - 27, 81, 455, 30, 370, 570, 452, 329, 329, 347, - 348, 352, 366, 352, 634, 366, 374, 672, 486, 361, - 374, 676, 357, 374, 365, 390, 391, 392, 414, 684, - 428, 498, 652, 500, 367, 369, 503, 371, 371, 364, - 412, 413, 345, 346, 382, 383, 381, 368, 387, 390, - 391, 364, 374, 366, 371, 366, 364, 366, 504, 431, - 373, 364, 373, 366, 373, 366, 376, 370, 378, 365, - 368, 365, 373, 371, 446, 371, 374, 449, 365, 465, - 446, 467, 365, 449, 371, 365, 365, 365, 371, 365, - 558, 371, 371, 371, 371, 371, 549, 374, 371, 329, - 498, 374, 500, 343, 344, 503, 529, 530, 531, 532, - 371, 453, 371, 374, 366, 374, 329, 452, 371, 517, - 455, 374, 371, 688, 591, 374, 368, 513, 354, 355, - 356, 357, 358, 359, 360, 361, 362, 363, 379, 380, - 381, 368, 595, 349, 350, 525, 526, 373, 371, 372, - 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, - 532, 533, 534, 535, 536, 537, 538, 539, 540, 504, - 638, 371, 372, 329, 560, 329, 643, 366, 564, 527, - 528, 533, 534, 373, 582, 583, 374, 329, 365, 364, - 386, 385, 384, 591, 351, 353, 367, 329, 329, 364, - 374, 374, 364, 364, 374, 372, 366, 329, 329, 364, - 551, 329, 364, 364, 549, 365, 369, 328, 367, 367, - 364, 364, 689, 368, 371, 329, 365, 367, 369, 365, - 698, 25, 369, 368, 368, 621, 374, 365, 535, 538, - 373, 536, 659, 357, 374, 643, 537, 539, 634, 329, - 540, 361, 361, 451, 322, 626, 629, 550, 671, 684, - 595, 685, 355, 496, 652, 629, 652, 665, 496, 344, - 661, 496, -1, -1, -1, -1, -1, -1, -1, -1, - 666, -1, -1, -1, -1, -1, -1, 659, -1, -1, - -1, 689, -1, 659, -1, -1, -1, 683, -1, 634, - -1, 328, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 657, -1, 652, 328, -1, - -1, -1, -1, -1, 328, -1, 336, -1, -1, -1, - -1, -1, 336, -1, 344, 344, 344, -1, -1, -1, - 344, 351, -1, -1, -1, -1, -1, 357, -1, -1, - -1, 361, -1, 357, -1, -1, -1, 361, -1, -1, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, -1, -1, 348, 349, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 381, -1, -1, -1, 385, -1, 381, -1, -1, - -1, 385, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 452, 453, -1, 455, -1, -1, 452, 453, - -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, 486, -1, -1, -1, - -1, -1, 486, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 504, -1, -1, -1, -1, -1, - 504, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 549, - -1, -1, -1, -1, -1, 549, -1, -1, 558, -1, - -1, -1, -1, -1, 558, -1, -1, -1, -1, -1, - 570, -1, -1, -1, -1, -1, 570, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 595, -1, -1, -1, -1, - -1, 595, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 629, - -1, -1, -1, -1, 634, 629, -1, -1, 638, -1, - 634, -1, -1, -1, 638, -1, -1, -1, -1, -1, - -1, -1, 652, -1, -1, -1, -1, 657, 652, -1, - -1, -1, -1, 657, -1, -1, -1, -1, -1, -1, - -1, -1, 672, -1, -1, -1, 676, -1, 672, -1, - -1, -1, 676, -1, 684, -1, -1, -1, 688, -1, - 684, -1, -1, -1, 688, -1, -1, -1, 698, -1, - -1, -1, 0, -1, 698, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - -1, -1, 330, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 374, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 388, 389, 390, 391, 392, 393, 3, 4, 5, 6, + -1, -1, -1, -1, -1, -1, 367, -1, 369, -1, + 371, 372, -1, -1, -1, -1, 377, 378, 379, 380, + 381, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 391, 392, 393, 394, 395, 396, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, @@ -2423,129 +2474,12 @@ static const yytype_int16 yycheck[] = 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, 339, 340, 341, 342, -1, -1, 345, 346, + 337, 338, 339, 340, 341, 342, 343, 344, 345, -1, + -1, 348, 349, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 364, -1, 366, - -1, 368, 369, -1, -1, -1, -1, 374, 375, 376, - 377, 378, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 388, 389, 390, 391, 392, 393, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, -1, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, - 336, 337, 338, 339, 340, 341, 342, -1, -1, 345, - 346, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 364, -1, - 366, -1, 368, 369, -1, -1, -1, -1, 374, 375, - 376, 377, 378, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 388, 389, 390, 391, 392, 393, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 337, 338, 339, 340, 341, 342, -1, -1, - 345, 346, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 364, - -1, 366, -1, 368, -1, -1, -1, -1, -1, 374, - 375, 376, 377, 378, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 388, 389, 390, 391, 392, 393, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, -1, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, 335, 336, 337, 338, 339, 340, 341, 342, -1, - -1, 345, 346, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 364, -1, 366, -1, 368, -1, -1, -1, -1, -1, - 374, 375, 376, 377, 378, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 388, 389, 390, 391, 392, 393, + 367, -1, 369, -1, 371, 372, -1, -1, -1, -1, + 377, 378, 379, 380, 381, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 391, 392, 393, 394, 395, 396, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, -1, 26, 27, 28, 29, 30, 31, 32, @@ -2580,51 +2514,91 @@ static const yytype_int16 yycheck[] = 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, - -1, -1, 345, 346, -1, -1, -1, -1, -1, -1, + 343, 344, 345, -1, -1, 348, 349, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 364, -1, 366, -1, -1, -1, -1, -1, -1, - -1, 374, 375, 376, 377, 378, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 388, 389, 390, 391, 392, - 393, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + -1, -1, -1, -1, 367, -1, 369, -1, 371, -1, + -1, -1, -1, -1, 377, 378, 379, 380, 381, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 391, 392, + 393, 394, 395, 396, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, -1, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, -1, -1, 348, + 349, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 367, -1, + 369, -1, 371, -1, -1, -1, -1, -1, 377, 378, + 379, 380, 381, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 391, 392, 393, 394, 395, 396, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, -1, -1, 348, 349, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 323, 324, 325, 326, 327, -1, 329, 330, 331, - 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, - 342, -1, -1, 345, 346, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 364, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 374, 375, 376, 377, 378, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 388, 389, 390, 391, - 392, 393, 3, 4, 5, 6, 7, 8, 9, 10, + -1, -1, 367, -1, 369, -1, -1, -1, -1, -1, + -1, -1, 377, 378, 379, 380, 381, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 391, 392, 393, 394, + 395, 396, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, 40, @@ -2656,294 +2630,26 @@ static const yytype_int16 yycheck[] = 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, -1, -1, 330, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + -1, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, -1, -1, 348, 349, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 374, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 388, 389, 390, - 391, 392, 393, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, -1, 329, - 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, - 340, 341, 342, -1, -1, 345, 346, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 364, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 375, 376, 377, 378, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 388, 389, - 390, 391, 392, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, -1, 329, - 330, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 374, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 388, 389, - 390, 391, 392, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, -1, -1, - 330, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 369, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 388, 389, - 390, 391, 392, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, -1, -1, - 330, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 369, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 388, 389, - 390, 391, 392, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, -1, -1, - 330, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 369, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 388, 389, - 390, 391, 392, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, -1, -1, - 330, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 5, 6, 7, 8, 9, -1, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, -1, -1, -1, -1, -1, -1, -1, 388, 389, - 390, 391, 392, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 82, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, -1, -1, -1, -1, - -1, -1, 123, 124, 125, 126, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, -1, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, - 341, 342, -1, -1, 345, 346, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 364, -1, -1, -1, 368, 369, -1, - -1, -1, -1, -1, 375, 376, 377, 378, 5, 6, - 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, + -1, -1, -1, -1, -1, -1, 367, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 377, 378, 379, 380, + 381, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 391, 392, 393, 394, 395, 396, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 34, 35, 36, + -1, -1, -1, -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 82, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 93, 94, 95, 96, + 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, - -1, -1, -1, -1, -1, -1, 123, 124, 125, 126, + 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, @@ -2964,23 +2670,25 @@ static const yytype_int16 yycheck[] = 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, -1, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, 339, 340, 341, 342, -1, -1, 345, 346, + 327, 328, 329, 330, -1, -1, 333, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 364, -1, -1, - 367, -1, -1, -1, -1, -1, -1, -1, 375, 376, - 377, 378, 5, 6, 7, 8, 9, -1, 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, -1, -1, -1, -1, + 377, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 391, 392, 393, 394, 395, 396, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 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, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 82, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 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, -1, -1, -1, -1, -1, -1, + 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, @@ -3001,12 +2709,245 @@ static const yytype_int16 yycheck[] = 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, -1, 329, 330, 331, 332, + 323, 324, 325, 326, 327, 328, 329, 330, -1, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, - -1, -1, 345, 346, -1, -1, -1, -1, -1, -1, + 343, 344, 345, -1, -1, 348, 349, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 364, -1, -1, -1, 368, -1, -1, -1, -1, - -1, -1, 375, 376, 377, 378, 5, 6, 7, 8, + -1, -1, -1, -1, 367, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 378, 379, 380, 381, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 391, 392, + 393, 394, 395, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, -1, 332, 333, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 377, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 391, 392, 393, 394, 395, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, 329, 330, -1, -1, 333, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 372, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 391, 392, 393, 394, 395, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, 330, -1, -1, 333, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 372, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 391, 392, 393, + 394, 395, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + -1, -1, 333, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 372, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 391, 392, 393, 394, 395, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, -1, -1, 333, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, + 6, 7, 8, 9, -1, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, + -1, -1, -1, 391, 392, 393, 394, 395, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 82, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, -1, 332, 333, 334, 335, + 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, + -1, -1, 348, 349, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 367, -1, -1, -1, 371, 372, -1, -1, -1, + -1, -1, 378, 379, 380, 381, 5, 6, 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 34, 35, 36, 37, 38, @@ -3018,7 +2959,7 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, -1, - -1, -1, -1, -1, 123, 124, 125, 126, 127, 128, + -1, -1, -1, -1, -1, -1, -1, 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, @@ -3038,12 +2979,50 @@ static const yytype_int16 yycheck[] = 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, -1, - 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, - 339, 340, 341, 342, -1, -1, 345, 346, -1, -1, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, -1, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, -1, -1, 348, + 349, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 367, -1, + -1, 370, -1, -1, -1, -1, -1, -1, -1, 378, + 379, 380, 381, 5, 6, 7, 8, 9, -1, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 364, -1, -1, 367, -1, - -1, -1, -1, -1, -1, -1, 375, 376, 377, 378, + -1, -1, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 82, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, -1, + 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, -1, -1, 348, 349, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 367, -1, -1, -1, 371, + -1, -1, -1, -1, -1, -1, 378, 379, 380, 381, 5, 6, 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 34, @@ -3055,8 +3034,8 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, -1, -1, -1, -1, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, -1, -1, -1, -1, -1, -1, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 115, 116, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 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, @@ -3076,12 +3055,50 @@ static const yytype_int16 yycheck[] = 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - 335, 336, 337, 338, 339, 340, 341, 342, -1, -1, - 345, 346, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 364, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 374, - 375, 376, 377, 378, 5, 6, 7, 8, 9, -1, + 325, 326, 327, 328, 329, 330, -1, 332, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, -1, -1, 348, 349, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 367, -1, -1, 370, -1, -1, -1, -1, + -1, -1, -1, 378, 379, 380, 381, 5, 6, 7, + 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 82, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, -1, 332, 333, 334, 335, 336, 337, + 338, 339, 340, 341, 342, 343, 344, 345, -1, -1, + 348, 349, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 367, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 377, + 378, 379, 380, 381, 5, 6, 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 34, 35, 36, 37, 38, 39, 40, @@ -3093,7 +3110,7 @@ static const yytype_int16 yycheck[] = -1, -1, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, -1, -1, -1, - -1, -1, 123, 124, 125, 126, 127, 128, 129, 130, + -1, -1, -1, -1, -1, 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, @@ -3113,12 +3130,50 @@ static const yytype_int16 yycheck[] = 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, -1, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, - 341, 342, -1, -1, 345, 346, -1, -1, -1, -1, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + -1, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, -1, -1, 348, 349, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 364, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 375, 376, 377, 378, 5, 6, + -1, -1, -1, -1, -1, -1, 367, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 378, 379, 380, + 381, 5, 6, 7, 8, 9, -1, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 82, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, 330, -1, 332, 333, + 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, + 344, 345, -1, -1, 348, 349, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 367, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 378, 379, 380, 381, 5, 6, 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 34, 35, 36, @@ -3126,11 +3181,11 @@ static const yytype_int16 yycheck[] = 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 82, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, -1, -1, -1, -1, -1, 123, 124, 125, 126, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 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, @@ -3151,44 +3206,7 @@ static const yytype_int16 yycheck[] = 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, -1, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, 339, 340, 341, 342, -1, -1, 345, 346, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 364, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 375, 376, - 377, 378, 5, 6, 7, 8, 9, -1, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, -1, -1, -1, -1, -1, -1, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, -1, -1, 330 + 327, 328, 329, 330, -1, -1, 333 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing @@ -3226,108 +3244,108 @@ static const yytype_uint16 yystos[] = 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 330, 374, 388, 389, 390, - 391, 392, 393, 428, 429, 432, 433, 434, 435, 439, - 440, 441, 442, 443, 444, 447, 448, 449, 450, 451, - 453, 455, 456, 457, 497, 498, 499, 364, 364, 329, - 368, 456, 329, 374, 374, 500, 365, 371, 436, 437, - 438, 448, 453, 371, 374, 329, 329, 374, 449, 453, - 366, 454, 0, 498, 329, 452, 81, 329, 445, 446, - 368, 459, 453, 374, 454, 368, 476, 437, 436, 438, - 329, 329, 364, 373, 454, 368, 371, 374, 431, 329, - 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 345, 346, 364, 367, 375, 376, 377, 378, - 398, 399, 400, 402, 403, 404, 405, 406, 407, 408, + 323, 324, 325, 326, 327, 328, 329, 330, 333, 377, + 391, 392, 393, 394, 395, 396, 431, 432, 435, 436, + 437, 438, 442, 443, 444, 445, 446, 447, 450, 451, + 452, 453, 454, 456, 458, 459, 460, 500, 501, 502, + 367, 367, 332, 371, 459, 332, 377, 377, 503, 368, + 374, 439, 440, 441, 451, 456, 374, 377, 332, 332, + 377, 452, 456, 369, 457, 0, 501, 332, 455, 81, + 332, 448, 449, 371, 462, 456, 377, 457, 371, 479, + 440, 439, 441, 332, 332, 367, 376, 457, 371, 374, + 377, 434, 332, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 348, 349, 367, 370, 378, + 379, 380, 381, 401, 402, 403, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 421, 422, 451, 453, 366, 365, 371, 373, - 365, 371, 458, 448, 453, 460, 461, 374, 374, 22, - 23, 24, 26, 27, 28, 29, 30, 31, 32, 328, - 366, 368, 369, 374, 409, 422, 424, 426, 428, 432, - 451, 453, 466, 467, 468, 469, 477, 478, 479, 480, - 483, 484, 487, 488, 489, 496, 501, 454, 373, 454, - 368, 424, 464, 373, 430, 329, 371, 374, 409, 409, - 426, 345, 346, 366, 370, 365, 365, 371, 327, 424, - 364, 409, 379, 380, 381, 376, 378, 343, 344, 347, - 348, 382, 383, 349, 350, 386, 385, 384, 351, 353, - 352, 387, 367, 367, 422, 329, 422, 427, 446, 460, - 453, 329, 462, 463, 369, 461, 374, 374, 491, 364, - 364, 374, 374, 426, 364, 426, 372, 364, 366, 369, - 470, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 373, 425, 371, 374, 369, 467, 480, 484, 489, - 464, 373, 464, 465, 464, 460, 329, 365, 401, 426, - 329, 424, 409, 409, 409, 411, 411, 412, 412, 413, - 413, 413, 413, 414, 414, 415, 416, 417, 418, 419, - 420, 423, 367, 369, 462, 454, 371, 374, 467, 492, - 426, 374, 426, 372, 490, 329, 502, 503, 477, 424, - 424, 464, 369, 371, 369, 367, 426, 374, 463, 328, - 466, 478, 493, 365, 365, 426, 441, 448, 482, 364, - 367, 371, 471, 369, 464, 372, 364, 482, 494, 495, - 473, 474, 475, 481, 485, 329, 365, 427, 367, 503, - 369, 424, 426, 374, 365, 25, 469, 468, 368, 373, - 468, 472, 476, 365, 365, 426, 472, 473, 477, 486, - 464, 374, 369 + 419, 420, 421, 422, 423, 424, 425, 454, 456, 369, + 368, 374, 376, 368, 374, 461, 451, 456, 463, 464, + 377, 377, 22, 23, 24, 26, 27, 28, 29, 30, + 31, 32, 331, 369, 371, 372, 377, 412, 425, 427, + 429, 431, 435, 454, 456, 469, 470, 471, 472, 480, + 481, 482, 483, 486, 487, 490, 491, 492, 499, 504, + 457, 376, 457, 371, 427, 467, 376, 433, 332, 374, + 377, 412, 412, 429, 348, 349, 369, 373, 368, 368, + 374, 330, 427, 367, 412, 382, 383, 384, 379, 381, + 346, 347, 350, 351, 385, 386, 352, 353, 389, 388, + 387, 354, 356, 355, 390, 370, 370, 425, 332, 425, + 430, 449, 463, 456, 332, 465, 466, 372, 464, 377, + 377, 494, 367, 367, 377, 377, 429, 367, 429, 375, + 367, 369, 372, 473, 357, 358, 359, 360, 361, 362, + 363, 364, 365, 366, 376, 428, 374, 377, 372, 470, + 483, 487, 492, 467, 376, 467, 468, 467, 463, 332, + 368, 404, 429, 332, 427, 412, 412, 412, 414, 414, + 415, 415, 416, 416, 416, 416, 417, 417, 418, 419, + 420, 421, 422, 423, 426, 370, 372, 465, 457, 374, + 377, 470, 495, 429, 377, 429, 375, 493, 332, 505, + 506, 480, 427, 427, 467, 372, 374, 372, 370, 429, + 377, 466, 331, 469, 481, 496, 368, 368, 429, 444, + 451, 485, 367, 370, 374, 474, 372, 467, 375, 367, + 485, 497, 498, 476, 477, 478, 484, 488, 332, 368, + 430, 370, 506, 372, 427, 429, 377, 368, 25, 472, + 471, 371, 376, 471, 475, 479, 368, 368, 429, 475, + 476, 480, 489, 467, 377, 372 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint16 yyr1[] = { - 0, 397, 398, 399, 399, 399, 399, 399, 399, 399, - 399, 399, 399, 399, 399, 399, 399, 400, 400, 400, - 400, 400, 400, 401, 402, 403, 404, 404, 405, 405, - 406, 406, 407, 408, 408, 408, 409, 409, 409, 409, - 410, 410, 410, 410, 411, 411, 411, 411, 412, 412, - 412, 413, 413, 413, 414, 414, 414, 414, 414, 415, - 415, 415, 416, 416, 417, 417, 418, 418, 419, 419, - 420, 420, 421, 421, 422, 423, 422, 424, 424, 425, - 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, - 426, 426, 427, 428, 428, 428, 428, 428, 428, 428, - 428, 428, 430, 429, 431, 431, 432, 433, 433, 434, - 434, 435, 436, 436, 437, 437, 437, 437, 438, 439, - 439, 439, 439, 439, 440, 440, 440, 440, 440, 441, - 441, 442, 443, 443, 443, 443, 443, 444, 445, 445, - 446, 446, 446, 447, 448, 448, 449, 449, 449, 449, - 449, 449, 449, 450, 450, 450, 450, 450, 450, 450, - 450, 450, 450, 450, 450, 450, 450, 450, 450, 450, - 450, 450, 450, 450, 450, 450, 450, 451, 452, 452, - 453, 453, 454, 454, 454, 454, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, - 455, 456, 456, 456, 458, 457, 459, 457, 460, 460, - 461, 461, 462, 462, 463, 463, 464, 464, 464, 465, - 465, 466, 467, 467, 468, 468, 468, 468, 468, 468, - 468, 469, 470, 471, 469, 472, 472, 474, 473, 475, - 473, 476, 476, 477, 477, 478, 478, 479, 479, 480, - 481, 481, 482, 482, 483, 483, 485, 484, 486, 486, - 487, 487, 488, 488, 490, 489, 491, 489, 492, 489, - 493, 493, 494, 494, 495, 495, 496, 496, 496, 496, - 496, 497, 497, 498, 498, 498, 500, 499, 501, 502, - 502, 503, 503 + 0, 400, 401, 402, 402, 402, 402, 402, 402, 402, + 402, 402, 402, 402, 402, 402, 402, 403, 403, 403, + 403, 403, 403, 404, 405, 406, 407, 407, 408, 408, + 409, 409, 410, 411, 411, 411, 412, 412, 412, 412, + 413, 413, 413, 413, 414, 414, 414, 414, 415, 415, + 415, 416, 416, 416, 417, 417, 417, 417, 417, 418, + 418, 418, 419, 419, 420, 420, 421, 421, 422, 422, + 423, 423, 424, 424, 425, 426, 425, 427, 427, 428, + 428, 428, 428, 428, 428, 428, 428, 428, 428, 428, + 429, 429, 430, 431, 431, 431, 431, 431, 431, 431, + 431, 431, 433, 432, 434, 434, 435, 436, 436, 437, + 437, 438, 439, 439, 440, 440, 440, 440, 441, 442, + 442, 442, 442, 442, 443, 443, 443, 443, 443, 444, + 444, 445, 446, 446, 446, 446, 446, 446, 446, 446, + 447, 448, 448, 449, 449, 449, 450, 451, 451, 452, + 452, 452, 452, 452, 452, 452, 453, 453, 453, 453, + 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, + 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, + 454, 455, 455, 456, 456, 457, 457, 457, 457, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 458, 458, 458, 458, 458, 458, + 458, 458, 458, 458, 459, 459, 459, 461, 460, 462, + 460, 463, 463, 464, 464, 465, 465, 466, 466, 467, + 467, 467, 468, 468, 469, 470, 470, 471, 471, 471, + 471, 471, 471, 471, 472, 473, 474, 472, 475, 475, + 477, 476, 478, 476, 479, 479, 480, 480, 481, 481, + 482, 482, 483, 484, 484, 485, 485, 486, 486, 488, + 487, 489, 489, 490, 490, 491, 491, 493, 492, 494, + 492, 495, 492, 496, 496, 497, 497, 498, 498, 499, + 499, 499, 499, 499, 500, 500, 501, 501, 501, 503, + 502, 504, 505, 505, 506, 506 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ @@ -3346,12 +3364,12 @@ static const yytype_uint8 yyr2[] = 3, 4, 0, 6, 2, 3, 2, 1, 1, 2, 3, 3, 2, 3, 2, 1, 2, 1, 1, 1, 3, 4, 6, 5, 1, 2, 3, 5, 4, 1, - 2, 1, 1, 1, 1, 1, 1, 4, 1, 3, - 1, 3, 1, 1, 1, 2, 1, 1, 1, 1, + 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 4, 1, 3, 1, 3, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 4, 1, 1, 3, - 1, 2, 2, 3, 3, 4, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, + 1, 1, 3, 1, 2, 2, 3, 3, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -3380,16 +3398,16 @@ static const yytype_uint8 yyr2[] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 0, 6, 0, 5, 1, 2, - 3, 4, 1, 3, 1, 2, 1, 3, 4, 1, - 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 2, 0, 0, 5, 1, 1, 0, 2, 0, - 2, 2, 3, 1, 2, 1, 2, 1, 2, 5, - 3, 1, 1, 4, 1, 2, 0, 8, 0, 1, - 3, 2, 1, 2, 0, 6, 0, 8, 0, 7, - 1, 1, 1, 0, 2, 3, 2, 2, 2, 3, - 2, 1, 2, 1, 1, 1, 0, 3, 5, 1, - 3, 1, 4 + 1, 1, 1, 1, 1, 1, 1, 0, 6, 0, + 5, 1, 2, 3, 4, 1, 3, 1, 2, 1, + 3, 4, 1, 3, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 2, 0, 0, 5, 1, 1, + 0, 2, 0, 2, 2, 3, 1, 2, 1, 2, + 1, 2, 5, 3, 1, 1, 4, 1, 2, 0, + 8, 0, 1, 3, 2, 1, 2, 0, 6, 0, + 8, 0, 7, 1, 1, 1, 0, 2, 3, 2, + 2, 2, 3, 2, 1, 2, 1, 1, 1, 0, + 3, 5, 1, 3, 1, 4 }; @@ -4076,7 +4094,7 @@ yyreduce: { (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string); } -#line 4080 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4098 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 3: @@ -4084,7 +4102,7 @@ yyreduce: { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4088 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4106 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 4: @@ -4093,7 +4111,7 @@ yyreduce: parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 4097 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4115 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 5: @@ -4102,7 +4120,7 @@ yyreduce: parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 4106 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4124 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 6: @@ -4110,7 +4128,7 @@ yyreduce: { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 4114 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4132 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 7: @@ -4119,7 +4137,7 @@ yyreduce: parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 4123 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 8: @@ -4128,7 +4146,7 @@ yyreduce: parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true); } -#line 4132 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4150 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 9: @@ -4137,7 +4155,7 @@ yyreduce: parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true); } -#line 4141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4159 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 10: @@ -4146,7 +4164,7 @@ yyreduce: parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 4150 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4168 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 11: @@ -4155,7 +4173,7 @@ yyreduce: parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 4159 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 12: @@ -4163,7 +4181,7 @@ yyreduce: { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 4167 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4185 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 13: @@ -4172,7 +4190,7 @@ yyreduce: parseContext.doubleCheck((yyvsp[0].lex).loc, "double literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtDouble, (yyvsp[0].lex).loc, true); } -#line 4176 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4194 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 14: @@ -4181,7 +4199,7 @@ yyreduce: parseContext.float16Check((yyvsp[0].lex).loc, "half float literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true); } -#line 4185 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4203 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 15: @@ -4189,7 +4207,7 @@ yyreduce: { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 4193 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4211 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 16: @@ -4199,7 +4217,7 @@ yyreduce: if ((yyval.interm.intermTypedNode)->getAsConstantUnion()) (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } -#line 4203 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 17: @@ -4207,7 +4225,7 @@ yyreduce: { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4211 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4229 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 18: @@ -4215,7 +4233,7 @@ yyreduce: { (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode)); } -#line 4219 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4237 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 19: @@ -4223,7 +4241,7 @@ yyreduce: { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4227 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4245 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 20: @@ -4231,7 +4249,7 @@ yyreduce: { (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string); } -#line 4235 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4253 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 21: @@ -4241,7 +4259,7 @@ yyreduce: parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode)); } -#line 4245 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4263 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 22: @@ -4251,7 +4269,7 @@ yyreduce: parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode)); } -#line 4255 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4273 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 23: @@ -4260,7 +4278,7 @@ yyreduce: parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]"); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4282 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 24: @@ -4269,7 +4287,7 @@ yyreduce: (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode); delete (yyvsp[0].interm).function; } -#line 4273 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4291 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 25: @@ -4277,7 +4295,7 @@ yyreduce: { (yyval.interm) = (yyvsp[0].interm); } -#line 4281 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4299 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 26: @@ -4286,7 +4304,7 @@ yyreduce: (yyval.interm) = (yyvsp[-1].interm); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 4290 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4308 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 27: @@ -4295,7 +4313,7 @@ yyreduce: (yyval.interm) = (yyvsp[-1].interm); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 4299 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4317 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 28: @@ -4303,7 +4321,7 @@ yyreduce: { (yyval.interm) = (yyvsp[-1].interm); } -#line 4307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 29: @@ -4311,7 +4329,7 @@ yyreduce: { (yyval.interm) = (yyvsp[0].interm); } -#line 4315 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 30: @@ -4323,7 +4341,7 @@ yyreduce: (yyval.interm).function = (yyvsp[-1].interm).function; (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode); } -#line 4327 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4345 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 31: @@ -4335,7 +4353,7 @@ yyreduce: (yyval.interm).function = (yyvsp[-2].interm).function; (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); } -#line 4339 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4357 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 32: @@ -4343,7 +4361,7 @@ yyreduce: { (yyval.interm) = (yyvsp[-1].interm); } -#line 4347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 33: @@ -4353,7 +4371,7 @@ yyreduce: (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 4357 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 34: @@ -4385,7 +4403,7 @@ yyreduce: (yyval.interm).function = new TFunction(&empty, TType(EbtVoid), EOpNull); } } -#line 4389 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4407 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 35: @@ -4395,7 +4413,7 @@ yyreduce: (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 4399 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4417 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 36: @@ -4406,7 +4424,7 @@ yyreduce: if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode()) parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), ""); } -#line 4410 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 37: @@ -4415,7 +4433,7 @@ yyreduce: parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode)); } -#line 4419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4437 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 38: @@ -4424,7 +4442,7 @@ yyreduce: parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode)); } -#line 4428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 39: @@ -4445,38 +4463,38 @@ yyreduce: (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } } -#line 4449 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4467 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 40: #line 519 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; } -#line 4455 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4473 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 41: #line 520 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; } -#line 4461 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 42: #line 521 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; } -#line 4467 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 43: #line 522 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot; parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); } -#line 4474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4492 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 44: #line 528 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4498 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 45: @@ -4486,7 +4504,7 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4490 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4508 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 46: @@ -4496,7 +4514,7 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4500 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4518 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 47: @@ -4507,13 +4525,13 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4511 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4529 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 48: #line 548 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4517 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4535 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 49: @@ -4523,7 +4541,7 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4527 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4545 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 50: @@ -4533,13 +4551,13 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4555 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 51: #line 562 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4543 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4561 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 52: @@ -4550,7 +4568,7 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4554 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4572 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 53: @@ -4561,13 +4579,13 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4565 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4583 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 54: #line 578 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4571 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4589 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 55: @@ -4577,7 +4595,7 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4581 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4599 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 56: @@ -4587,7 +4605,7 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4591 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4609 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 57: @@ -4597,7 +4615,7 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4601 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4619 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 58: @@ -4607,13 +4625,13 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4611 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4629 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 59: #line 602 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4617 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4635 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 60: @@ -4626,7 +4644,7 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4630 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 61: @@ -4639,13 +4657,13 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4643 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 62: #line 622 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4649 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4667 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 63: @@ -4656,13 +4674,13 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4660 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 64: #line 632 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4666 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4684 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 65: @@ -4673,13 +4691,13 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4677 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4695 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 66: #line 642 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4701 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 67: @@ -4690,13 +4708,13 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4694 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4712 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 68: #line 652 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4700 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4718 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 69: @@ -4706,13 +4724,13 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4728 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 70: #line 661 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4716 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4734 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 71: @@ -4722,13 +4740,13 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4726 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4744 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 72: #line 670 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4750 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 73: @@ -4738,13 +4756,13 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4760 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 74: #line 679 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4748 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4766 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 75: @@ -4752,7 +4770,7 @@ yyreduce: { ++parseContext.controlFlowNestingLevel; } -#line 4756 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4774 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 76: @@ -4769,13 +4787,13 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 4773 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4791 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 77: #line 698 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4779 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4797 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 78: @@ -4793,7 +4811,7 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } } -#line 4797 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 79: @@ -4802,7 +4820,7 @@ yyreduce: (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAssign; } -#line 4806 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4824 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 80: @@ -4811,7 +4829,7 @@ yyreduce: (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpMulAssign; } -#line 4815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 81: @@ -4820,7 +4838,7 @@ yyreduce: (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpDivAssign; } -#line 4824 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 82: @@ -4830,7 +4848,7 @@ yyreduce: (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpModAssign; } -#line 4834 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4852 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 83: @@ -4839,7 +4857,7 @@ yyreduce: (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAddAssign; } -#line 4843 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4861 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 84: @@ -4848,7 +4866,7 @@ yyreduce: (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpSubAssign; } -#line 4852 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4870 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 85: @@ -4857,7 +4875,7 @@ yyreduce: parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign; } -#line 4861 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4879 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 86: @@ -4866,7 +4884,7 @@ yyreduce: parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign; } -#line 4870 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4888 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 87: @@ -4875,7 +4893,7 @@ yyreduce: parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign; } -#line 4879 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4897 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 88: @@ -4884,7 +4902,7 @@ yyreduce: parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign; } -#line 4888 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4906 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 89: @@ -4893,7 +4911,7 @@ yyreduce: parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign; } -#line 4897 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4915 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 90: @@ -4901,7 +4919,7 @@ yyreduce: { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4923 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 91: @@ -4914,7 +4932,7 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 4918 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4936 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 92: @@ -4923,7 +4941,7 @@ yyreduce: parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), ""); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4927 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 93: @@ -4933,7 +4951,7 @@ yyreduce: (yyval.interm.intermNode) = 0; // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature } -#line 4937 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 94: @@ -4943,7 +4961,7 @@ yyreduce: (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence); (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode; } -#line 4947 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4965 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 95: @@ -4956,7 +4974,7 @@ yyreduce: parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision); (yyval.interm.intermNode) = 0; } -#line 4960 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4978 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 96: @@ -4965,7 +4983,7 @@ yyreduce: parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList); (yyval.interm.intermNode) = 0; } -#line 4969 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4987 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 97: @@ -4974,7 +4992,7 @@ yyreduce: parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string); (yyval.interm.intermNode) = 0; } -#line 4978 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 98: @@ -4983,7 +5001,7 @@ yyreduce: parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes); (yyval.interm.intermNode) = 0; } -#line 4987 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 99: @@ -4993,7 +5011,7 @@ yyreduce: parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type)); (yyval.interm.intermNode) = 0; } -#line 4997 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5015 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 100: @@ -5003,7 +5021,7 @@ yyreduce: parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].lex).string); (yyval.interm.intermNode) = 0; } -#line 5007 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5025 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 101: @@ -5014,13 +5032,13 @@ yyreduce: parseContext.addQualifierToExisting((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier, *(yyvsp[-1].interm.identifierList)); (yyval.interm.intermNode) = 0; } -#line 5018 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5036 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 102: #line 833 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); } -#line 5024 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5042 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 103: @@ -5034,7 +5052,7 @@ yyreduce: (yyval.interm).loc = (yyvsp[-5].interm.type).loc; (yyval.interm).typeList = (yyvsp[-1].interm.typeList); } -#line 5038 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5056 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 104: @@ -5043,7 +5061,7 @@ yyreduce: (yyval.interm.identifierList) = new TIdentifierList; (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 5047 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5065 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 105: @@ -5052,7 +5070,7 @@ yyreduce: (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList); (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 5056 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5074 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 106: @@ -5061,7 +5079,7 @@ yyreduce: (yyval.interm).function = (yyvsp[-1].interm.function); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 5065 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5083 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 107: @@ -5069,7 +5087,7 @@ yyreduce: { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 5073 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5091 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 108: @@ -5077,7 +5095,7 @@ yyreduce: { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 5081 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5099 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 109: @@ -5090,7 +5108,7 @@ yyreduce: else delete (yyvsp[0].interm).param.type; } -#line 5094 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 110: @@ -5112,7 +5130,7 @@ yyreduce: (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param); } } -#line 5116 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5134 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 111: @@ -5136,7 +5154,7 @@ yyreduce: function = new TFunction((yyvsp[-1].lex).string, type); (yyval.interm.function) = function; } -#line 5140 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5158 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 112: @@ -5156,7 +5174,7 @@ yyreduce: (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).param = param; } -#line 5160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5178 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 113: @@ -5180,7 +5198,7 @@ yyreduce: (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).param = param; } -#line 5184 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 114: @@ -5196,7 +5214,7 @@ yyreduce: parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); } -#line 5200 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5218 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 115: @@ -5208,7 +5226,7 @@ yyreduce: parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier()); } -#line 5212 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5230 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 116: @@ -5223,7 +5241,7 @@ yyreduce: parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type); parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); } -#line 5227 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5245 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 117: @@ -5235,7 +5253,7 @@ yyreduce: parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier()); } -#line 5239 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5257 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 118: @@ -5246,7 +5264,7 @@ yyreduce: if ((yyvsp[0].interm.type).arraySizes) parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes); } -#line 5250 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5268 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 119: @@ -5254,7 +5272,7 @@ yyreduce: { (yyval.interm) = (yyvsp[0].interm); } -#line 5258 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 120: @@ -5263,7 +5281,7 @@ yyreduce: (yyval.interm) = (yyvsp[-2].interm); parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type); } -#line 5267 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5285 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 121: @@ -5272,7 +5290,7 @@ yyreduce: (yyval.interm) = (yyvsp[-3].interm); parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes); } -#line 5276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5294 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 122: @@ -5282,7 +5300,7 @@ yyreduce: TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-5].interm).type, (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-5].interm).intermNode, initNode, (yyvsp[-1].lex).loc); } -#line 5286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5304 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 123: @@ -5292,7 +5310,7 @@ yyreduce: TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-4].interm).type, 0, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-4].interm).intermNode, initNode, (yyvsp[-1].lex).loc); } -#line 5296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5314 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 124: @@ -5302,7 +5320,7 @@ yyreduce: (yyval.interm).intermNode = 0; parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type); } -#line 5306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5324 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 125: @@ -5312,7 +5330,7 @@ yyreduce: (yyval.interm).intermNode = 0; parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type)); } -#line 5316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5334 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 126: @@ -5322,7 +5340,7 @@ yyreduce: (yyval.interm).intermNode = 0; parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes); } -#line 5326 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5344 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 127: @@ -5332,7 +5350,7 @@ yyreduce: TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-4].interm.type), (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); } -#line 5336 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5354 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 128: @@ -5342,7 +5360,7 @@ yyreduce: TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); } -#line 5346 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 129: @@ -5358,7 +5376,7 @@ yyreduce: parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier); } -#line 5362 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5380 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 130: @@ -5387,7 +5405,7 @@ yyreduce: (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn))) (yyval.interm.type).qualifier.smooth = true; } -#line 5391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5409 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 131: @@ -5398,7 +5416,7 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.invariant = true; } -#line 5402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5420 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 132: @@ -5410,7 +5428,7 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.smooth = true; } -#line 5414 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5432 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 133: @@ -5422,7 +5440,7 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.flat = true; } -#line 5426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5444 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 134: @@ -5438,7 +5456,7 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nopersp = true; } -#line 5442 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5460 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 135: @@ -5452,7 +5470,7 @@ yyreduce: (yyval.interm.type).qualifier.explicitInterp = true; #endif } -#line 5456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 136: @@ -5467,84 +5485,123 @@ yyreduce: (yyval.interm.type).qualifier.pervertexNV = true; #endif } -#line 5471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 137: -#line 1160 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1157 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - (yyval.interm.type) = (yyvsp[-1].interm.type); +#ifdef NV_EXTENSIONS + parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveNV"); + parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_NV_mesh_shader, "perprimitiveNV"); + (yyval.interm.type).init((yyvsp[0].lex).loc); + (yyval.interm.type).qualifier.perPrimitiveNV = true; +#endif } -#line 5479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5502 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 138: -#line 1166 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type) = (yyvsp[0].interm.type); - } -#line 5487 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 139: -#line 1169 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type) = (yyvsp[-2].interm.type); - (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); - parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); - } -#line 5497 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 140: -#line 1176 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1165 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { +#ifdef NV_EXTENSIONS + parseContext.globalCheck((yyvsp[0].lex).loc, "perviewNV"); + parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_NV_mesh_shader, "perviewNV"); (yyval.interm.type).init((yyvsp[0].lex).loc); - parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string); - } -#line 5506 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 141: -#line 1180 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[-2].lex).loc); - parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode)); + (yyval.interm.type).qualifier.perViewNV = true; +#endif } #line 5515 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 142: -#line 1184 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { // because "shared" is both an identifier and a keyword + case 139: +#line 1173 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { +#ifdef NV_EXTENSIONS + parseContext.globalCheck((yyvsp[0].lex).loc, "taskNV"); + parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_NV_mesh_shader, "taskNV"); (yyval.interm.type).init((yyvsp[0].lex).loc); - TString strShared("shared"); - parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared); + (yyval.interm.type).qualifier.perTaskNV = true; +#endif } -#line 5525 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5528 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 143: -#line 1192 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 140: +#line 1184 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise"); - parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise"); - (yyval.interm.type).init((yyvsp[0].lex).loc); - (yyval.interm.type).qualifier.noContraction = true; + (yyval.interm.type) = (yyvsp[-1].interm.type); } #line 5536 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 144: -#line 1201 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 141: +#line 1190 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } #line 5544 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 145: + case 142: +#line 1193 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type) = (yyvsp[-2].interm.type); + (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); + parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); + } +#line 5554 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 143: +#line 1200 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc); + parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string); + } +#line 5563 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 144: #line 1204 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[-2].lex).loc); + parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode)); + } +#line 5572 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 145: +#line 1208 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { // because "shared" is both an identifier and a keyword + (yyval.interm.type).init((yyvsp[0].lex).loc); + TString strShared("shared"); + parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared); + } +#line 5582 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 146: +#line 1216 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise"); + parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise"); + (yyval.interm.type).init((yyvsp[0].lex).loc); + (yyval.interm.type).qualifier.noContraction = true; + } +#line 5593 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 147: +#line 1225 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type) = (yyvsp[0].interm.type); + } +#line 5601 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 148: +#line 1228 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[-1].interm.type); if ((yyval.interm.type).basicType == EbtVoid) @@ -5553,80 +5610,80 @@ yyreduce: (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); parseContext.mergeQualifiers((yyval.interm.type).loc, (yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); } -#line 5557 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5614 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 146: -#line 1215 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 149: +#line 1239 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5565 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5622 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 147: -#line 1218 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 150: +#line 1242 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5573 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5630 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 148: -#line 1221 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 151: +#line 1245 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5582 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 149: -#line 1225 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - // allow inheritance of storage qualifier from block declaration - (yyval.interm.type) = (yyvsp[0].interm.type); - } -#line 5591 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 150: -#line 1229 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - // allow inheritance of storage qualifier from block declaration - (yyval.interm.type) = (yyvsp[0].interm.type); - } -#line 5600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 151: -#line 1233 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - // allow inheritance of storage qualifier from block declaration - (yyval.interm.type) = (yyvsp[0].interm.type); - } -#line 5609 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5639 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 152: -#line 1237 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1249 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { + // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5617 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 153: -#line 1243 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1253 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + // allow inheritance of storage qualifier from block declaration + (yyval.interm.type) = (yyvsp[0].interm.type); + } +#line 5657 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 154: +#line 1257 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + // allow inheritance of storage qualifier from block declaration + (yyval.interm.type) = (yyvsp[0].interm.type); + } +#line 5666 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 155: +#line 1261 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type) = (yyvsp[0].interm.type); + } +#line 5674 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 156: +#line 1267 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqConst; // will later turn into EvqConstReadOnly, if the initializer is not constant } -#line 5626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 154: -#line 1247 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 157: +#line 1271 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute"); @@ -5639,11 +5696,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 5643 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5700 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 155: -#line 1259 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 158: +#line 1283 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying"); @@ -5658,43 +5715,43 @@ yyreduce: else (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 5662 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5719 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 156: -#line 1273 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 159: +#line 1297 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "inout"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqInOut; } -#line 5672 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5729 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 157: -#line 1278 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 160: +#line 1302 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "in"); (yyval.interm.type).init((yyvsp[0].lex).loc); // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later (yyval.interm.type).qualifier.storage = EvqIn; } -#line 5683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5740 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 158: -#line 1284 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 161: +#line 1308 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "out"); (yyval.interm.type).init((yyvsp[0].lex).loc); // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later (yyval.interm.type).qualifier.storage = EvqOut; } -#line 5694 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 159: -#line 1290 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 162: +#line 1314 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid"); @@ -5702,239 +5759,243 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.centroid = true; } -#line 5706 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5763 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 160: -#line 1297 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 163: +#line 1321 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "patch"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.patch = true; } -#line 5717 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5774 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 161: -#line 1303 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 164: +#line 1327 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "sample"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.sample = true; } -#line 5727 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5784 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 162: -#line 1308 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 165: +#line 1332 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "uniform"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqUniform; } -#line 5737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5794 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 163: -#line 1313 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 166: +#line 1337 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "buffer"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqBuffer; } -#line 5747 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5804 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 164: -#line 1318 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 167: +#line 1342 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "shared"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 310, 0, "shared"); +#ifdef NV_EXTENSIONS + parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangComputeMask | EShLangMeshNVMask | EShLangTaskNVMask), "shared"); +#else parseContext.requireStage((yyvsp[0].lex).loc, EShLangCompute, "shared"); +#endif (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqShared; } -#line 5760 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5821 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 165: -#line 1326 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 168: +#line 1354 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.coherent = true; } -#line 5769 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5830 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 166: -#line 1330 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 169: +#line 1358 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent"); (yyval.interm.type).qualifier.devicecoherent = true; } -#line 5779 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5840 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 167: -#line 1335 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 170: +#line 1363 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent"); (yyval.interm.type).qualifier.queuefamilycoherent = true; } -#line 5789 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5850 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 168: -#line 1340 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 171: +#line 1368 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent"); (yyval.interm.type).qualifier.workgroupcoherent = true; } -#line 5799 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5860 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 169: -#line 1345 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 172: +#line 1373 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent"); (yyval.interm.type).qualifier.subgroupcoherent = true; } -#line 5809 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5870 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 170: -#line 1350 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 173: +#line 1378 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "nonprivate"); (yyval.interm.type).qualifier.nonprivate = true; } -#line 5819 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5880 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 171: -#line 1355 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 174: +#line 1383 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.volatil = true; } -#line 5828 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5889 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 172: -#line 1359 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 175: +#line 1387 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.restrict = true; } -#line 5837 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5898 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 173: -#line 1363 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 176: +#line 1391 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.readonly = true; } -#line 5846 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5907 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 174: -#line 1367 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 177: +#line 1395 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.writeonly = true; } -#line 5855 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5916 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 175: -#line 1371 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 178: +#line 1399 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.spvRemoved((yyvsp[0].lex).loc, "subroutine"); parseContext.globalCheck((yyvsp[0].lex).loc, "subroutine"); parseContext.unimplemented((yyvsp[0].lex).loc, "subroutine"); (yyval.interm.type).init((yyvsp[0].lex).loc); } -#line 5866 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5927 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 176: -#line 1377 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 179: +#line 1405 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.spvRemoved((yyvsp[-3].lex).loc, "subroutine"); parseContext.globalCheck((yyvsp[-3].lex).loc, "subroutine"); parseContext.unimplemented((yyvsp[-3].lex).loc, "subroutine"); (yyval.interm.type).init((yyvsp[-3].lex).loc); } -#line 5877 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5938 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 177: -#line 1386 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 180: +#line 1414 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nonUniform = true; } -#line 5886 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5947 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 178: -#line 1393 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 181: +#line 1421 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // TODO } -#line 5894 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 179: -#line 1396 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 182: +#line 1424 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // TODO: 4.0 semantics: subroutines // 1) make sure each identifier is a type declared earlier with SUBROUTINE // 2) save all of the identifiers for future comparison with the declared function } -#line 5904 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5965 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 180: -#line 1404 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 183: +#line 1432 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); } -#line 5913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5974 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 181: -#line 1408 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 184: +#line 1436 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes); (yyval.interm.type) = (yyvsp[-1].interm.type); (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes; } -#line 5924 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5985 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 182: -#line 1417 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 185: +#line 1445 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).arraySizes = new TArraySizes; (yyval.interm).arraySizes->addInnerSize(); } -#line 5934 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5995 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 183: -#line 1422 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 186: +#line 1450 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[-2].lex).loc; (yyval.interm).arraySizes = new TArraySizes; @@ -5943,20 +6004,20 @@ yyreduce: parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size); (yyval.interm).arraySizes->addInnerSize(size); } -#line 5947 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6008 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 184: -#line 1430 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 187: +#line 1458 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-2].interm); (yyval.interm).arraySizes->addInnerSize(); } -#line 5956 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6017 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 185: -#line 1434 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 188: +#line 1462 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-3].interm); @@ -5964,1484 +6025,1484 @@ yyreduce: parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size); (yyval.interm).arraySizes->addInnerSize(size); } -#line 5968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6029 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 186: -#line 1444 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 189: +#line 1472 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtVoid; } -#line 5977 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6038 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 187: -#line 1448 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 190: +#line 1476 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } -#line 5986 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6047 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 188: -#line 1452 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 191: +#line 1480 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; } -#line 5996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6057 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 189: -#line 1457 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 192: +#line 1485 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "float16_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; } -#line 6006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6067 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 190: -#line 1462 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 193: +#line 1490 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } -#line 6016 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6077 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 191: -#line 1467 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 194: +#line 1495 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; } -#line 6026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6087 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 192: -#line 1472 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 195: +#line 1500 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } -#line 6035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6096 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 193: -#line 1476 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 196: +#line 1504 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; } -#line 6045 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6106 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 194: -#line 1481 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 197: +#line 1509 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; } -#line 6055 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6116 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 195: -#line 1486 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 198: +#line 1514 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; } -#line 6065 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6126 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 196: -#line 1491 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 199: +#line 1519 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; } -#line 6075 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 197: -#line 1496 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 200: +#line 1524 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; } -#line 6085 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6146 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 198: -#line 1501 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 201: +#line 1529 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } -#line 6095 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6156 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 199: -#line 1506 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 202: +#line 1534 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; } -#line 6105 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 200: -#line 1511 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 203: +#line 1539 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; } -#line 6115 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6176 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 201: -#line 1516 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 204: +#line 1544 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; } -#line 6125 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 202: -#line 1521 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtBool; - } -#line 6134 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 203: -#line 1525 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setVector(2); - } -#line 6144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 204: -#line 1530 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setVector(3); - } -#line 6154 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 205: -#line 1535 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setVector(4); - } -#line 6164 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 206: -#line 1540 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(2); - } -#line 6175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 207: -#line 1546 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(3); - } #line 6186 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; + case 205: +#line 1549 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtBool; + } +#line 6195 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 206: +#line 1553 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setVector(2); + } +#line 6205 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 207: +#line 1558 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setVector(3); + } +#line 6215 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + case 208: -#line 1552 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1563 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setVector(4); + } +#line 6225 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 209: +#line 1568 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setVector(2); + } +#line 6236 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 210: +#line 1574 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setVector(3); + } +#line 6247 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 211: +#line 1580 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(4); } -#line 6197 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 209: -#line 1558 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setVector(2); - } -#line 6208 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 210: -#line 1564 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setVector(3); - } -#line 6219 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 211: -#line 1570 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setVector(4); - } -#line 6230 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6258 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 212: -#line 1576 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1586 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); + parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setVector(2); } -#line 6241 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6269 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 213: -#line 1582 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1592 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); + parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setVector(3); } -#line 6252 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6280 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 214: -#line 1588 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1598 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat16; + (yyval.interm.type).setVector(4); + } +#line 6291 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 215: +#line 1604 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setVector(2); + } +#line 6302 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 216: +#line 1610 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setVector(3); + } +#line 6313 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 217: +#line 1616 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(4); } -#line 6263 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 215: -#line 1594 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(2); - } -#line 6274 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 216: -#line 1600 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(3); - } -#line 6285 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 217: -#line 1606 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(4); - } -#line 6296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6324 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 218: -#line 1612 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1622 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { + parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtBool; + (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(2); } -#line 6306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6335 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 219: -#line 1617 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1628 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { + parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtBool; - (yyval.interm.type).setVector(3); - } -#line 6316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 220: -#line 1622 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtBool; - (yyval.interm.type).setVector(4); - } -#line 6326 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 221: -#line 1627 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt; - (yyval.interm.type).setVector(2); - } -#line 6336 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 222: -#line 1632 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(3); } #line 6346 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 223: -#line 1637 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 220: +#line 1634 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { + parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(4); } -#line 6356 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6357 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 224: -#line 1642 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 221: +#line 1640 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt8; + (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(2); } #line 6367 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 225: -#line 1648 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 222: +#line 1645 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt8; + (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(3); } -#line 6378 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6377 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 223: +#line 1650 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtBool; + (yyval.interm.type).setVector(4); + } +#line 6387 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 224: +#line 1655 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).setVector(2); + } +#line 6397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 225: +#line 1660 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).setVector(3); + } +#line 6407 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 226: -#line 1654 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1665 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).setVector(4); + } +#line 6417 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 227: +#line 1670 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt8; + (yyval.interm.type).setVector(2); + } +#line 6428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 228: +#line 1676 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt8; + (yyval.interm.type).setVector(3); + } +#line 6439 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 229: +#line 1682 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; (yyval.interm.type).setVector(4); } -#line 6389 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 227: -#line 1660 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt16; - (yyval.interm.type).setVector(2); - } -#line 6400 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 228: -#line 1666 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt16; - (yyval.interm.type).setVector(3); - } -#line 6411 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 229: -#line 1672 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt16; - (yyval.interm.type).setVector(4); - } -#line 6422 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6450 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 230: -#line 1678 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1688 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).basicType = EbtInt16; (yyval.interm.type).setVector(2); } -#line 6433 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6461 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 231: -#line 1684 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1694 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).basicType = EbtInt16; (yyval.interm.type).setVector(3); } -#line 6444 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6472 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 232: -#line 1690 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1700 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt16; + (yyval.interm.type).setVector(4); + } +#line 6483 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 233: +#line 1706 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).setVector(2); + } +#line 6494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 234: +#line 1712 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt; + (yyval.interm.type).setVector(3); + } +#line 6505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 235: +#line 1718 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(4); } -#line 6455 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 233: -#line 1696 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt64; - (yyval.interm.type).setVector(2); - } -#line 6466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 234: -#line 1702 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt64; - (yyval.interm.type).setVector(3); - } -#line 6477 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 235: -#line 1708 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtInt64; - (yyval.interm.type).setVector(4); - } -#line 6488 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6516 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 236: -#line 1714 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1724 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); + parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint; + (yyval.interm.type).basicType = EbtInt64; (yyval.interm.type).setVector(2); } -#line 6499 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6527 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 237: -#line 1720 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1730 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); + parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint; + (yyval.interm.type).basicType = EbtInt64; (yyval.interm.type).setVector(3); } -#line 6510 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6538 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 238: -#line 1726 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1736 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtInt64; + (yyval.interm.type).setVector(4); + } +#line 6549 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 239: +#line 1742 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint; + (yyval.interm.type).setVector(2); + } +#line 6560 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 240: +#line 1748 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint; + (yyval.interm.type).setVector(3); + } +#line 6571 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 241: +#line 1754 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(4); } -#line 6521 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 239: -#line 1732 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint8; - (yyval.interm.type).setVector(2); - } -#line 6532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 240: -#line 1738 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint8; - (yyval.interm.type).setVector(3); - } -#line 6543 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 241: -#line 1744 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint8; - (yyval.interm.type).setVector(4); - } -#line 6554 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6582 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 242: -#line 1750 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1760 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint16; + (yyval.interm.type).basicType = EbtUint8; (yyval.interm.type).setVector(2); } -#line 6565 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6593 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 243: -#line 1756 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1766 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint16; + (yyval.interm.type).basicType = EbtUint8; (yyval.interm.type).setVector(3); } -#line 6576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 244: -#line 1762 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1772 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint8; + (yyval.interm.type).setVector(4); + } +#line 6615 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 245: +#line 1778 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint16; + (yyval.interm.type).setVector(2); + } +#line 6626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 246: +#line 1784 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint16; + (yyval.interm.type).setVector(3); + } +#line 6637 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 247: +#line 1790 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; (yyval.interm.type).setVector(4); } -#line 6587 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 245: -#line 1768 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint; - (yyval.interm.type).setVector(2); - } -#line 6598 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 246: -#line 1774 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint; - (yyval.interm.type).setVector(3); - } -#line 6609 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 247: -#line 1780 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint; - (yyval.interm.type).setVector(4); - } -#line 6620 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 248: -#line 1786 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1796 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint; + (yyval.interm.type).setVector(2); + } +#line 6659 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 249: +#line 1802 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint; + (yyval.interm.type).setVector(3); + } +#line 6670 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 250: +#line 1808 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint; + (yyval.interm.type).setVector(4); + } +#line 6681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 251: +#line 1814 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; (yyval.interm.type).setVector(2); } -#line 6631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6692 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 249: -#line 1792 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 252: +#line 1820 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; (yyval.interm.type).setVector(3); } -#line 6642 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 250: -#line 1798 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtUint64; - (yyval.interm.type).setVector(4); - } -#line 6653 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 251: -#line 1804 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 2); - } -#line 6663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 252: -#line 1809 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(3, 3); - } -#line 6673 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 253: -#line 1814 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(4, 4); - } -#line 6683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 254: -#line 1819 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 2); - } -#line 6693 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 255: -#line 1824 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 3); - } #line 6703 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 256: -#line 1829 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 253: +#line 1826 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtUint64; + (yyval.interm.type).setVector(4); + } +#line 6714 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 254: +#line 1832 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 4); + (yyval.interm.type).setMatrix(2, 2); } -#line 6713 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6724 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 257: -#line 1834 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(3, 2); - } -#line 6723 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 258: -#line 1839 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 255: +#line 1837 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 6733 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6734 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 259: -#line 1844 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(3, 4); - } -#line 6743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 260: -#line 1849 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(4, 2); - } -#line 6753 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 261: -#line 1854 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(4, 3); - } -#line 6763 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 262: -#line 1859 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 256: +#line 1842 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 6773 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6744 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 263: -#line 1864 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 257: +#line 1847 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } +#line 6754 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 258: +#line 1852 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(2, 3); + } +#line 6764 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 259: +#line 1857 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(2, 4); + } +#line 6774 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 260: +#line 1862 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(3, 2); + } #line 6784 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 264: -#line 1870 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 261: +#line 1867 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 6795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6794 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 262: +#line 1872 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(3, 4); + } +#line 6804 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 263: +#line 1877 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(4, 2); + } +#line 6814 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 264: +#line 1882 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(4, 3); + } +#line 6824 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 265: -#line 1876 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1887 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 6806 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6834 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 266: -#line 1882 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1892 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 6817 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6845 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 267: -#line 1888 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1898 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(2, 3); + (yyval.interm.type).setMatrix(3, 3); } -#line 6828 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6856 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 268: -#line 1894 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1904 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(2, 4); + (yyval.interm.type).setMatrix(4, 4); } -#line 6839 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6867 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 269: -#line 1900 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1910 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(3, 2); + (yyval.interm.type).setMatrix(2, 2); } -#line 6850 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6878 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 270: -#line 1906 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1916 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(3, 3); + (yyval.interm.type).setMatrix(2, 3); } -#line 6861 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6889 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 271: -#line 1912 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1922 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(3, 4); + (yyval.interm.type).setMatrix(2, 4); } -#line 6872 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 272: -#line 1918 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1928 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(4, 2); + (yyval.interm.type).setMatrix(3, 2); } -#line 6883 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6911 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 273: -#line 1924 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1934 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(4, 3); + (yyval.interm.type).setMatrix(3, 3); } -#line 6894 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 274: -#line 1930 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1940 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setMatrix(3, 4); + } +#line 6933 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 275: +#line 1946 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setMatrix(4, 2); + } +#line 6944 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 276: +#line 1952 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setMatrix(4, 3); + } +#line 6955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 277: +#line 1958 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 6905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 275: -#line 1936 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(2, 2); - } -#line 6916 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 276: -#line 1942 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(3, 3); - } -#line 6927 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 277: -#line 1948 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(4, 4); - } -#line 6938 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 278: -#line 1954 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1964 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 2); } -#line 6949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6977 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 279: -#line 1960 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1970 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(2, 3); + (yyval.interm.type).setMatrix(3, 3); } -#line 6960 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6988 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 280: -#line 1966 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1976 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(2, 4); + (yyval.interm.type).setMatrix(4, 4); } -#line 6971 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6999 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 281: -#line 1972 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1982 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(3, 2); + (yyval.interm.type).setMatrix(2, 2); } -#line 6982 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7010 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 282: -#line 1978 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1988 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(3, 3); + (yyval.interm.type).setMatrix(2, 3); } -#line 6993 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 283: -#line 1984 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1994 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(3, 4); + (yyval.interm.type).setMatrix(2, 4); } -#line 7004 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7032 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 284: -#line 1990 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2000 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(4, 2); + (yyval.interm.type).setMatrix(3, 2); } -#line 7015 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7043 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 285: -#line 1996 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2006 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; - (yyval.interm.type).setMatrix(4, 3); + (yyval.interm.type).setMatrix(3, 3); } -#line 7026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7054 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 286: -#line 2002 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2012 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat16; + (yyval.interm.type).setMatrix(3, 4); + } +#line 7065 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 287: +#line 2018 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat16; + (yyval.interm.type).setMatrix(4, 2); + } +#line 7076 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 288: +#line 2024 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat16; + (yyval.interm.type).setMatrix(4, 3); + } +#line 7087 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 289: +#line 2030 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 4); } -#line 7037 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 287: -#line 2008 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 2); - } -#line 7048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 288: -#line 2014 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(3, 3); - } -#line 7059 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 289: -#line 2020 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(4, 4); - } -#line 7070 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7098 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 290: -#line 2026 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2036 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } -#line 7081 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7109 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 291: -#line 2032 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2042 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; - (yyval.interm.type).setMatrix(2, 3); + (yyval.interm.type).setMatrix(3, 3); } -#line 7092 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7120 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 292: -#line 2038 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2048 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(4, 4); + } +#line 7131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 293: +#line 2054 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(2, 2); + } +#line 7142 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 294: +#line 2060 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloat; + (yyval.interm.type).setMatrix(2, 3); + } +#line 7153 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 295: +#line 2066 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 4); } -#line 7103 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7164 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 293: -#line 2044 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 296: +#line 2072 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 2); } -#line 7114 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 294: -#line 2050 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 297: +#line 2078 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 7125 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7186 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 295: -#line 2056 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 298: +#line 2084 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 4); } -#line 7136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7197 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 296: -#line 2062 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 299: +#line 2090 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 2); } -#line 7147 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7208 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 297: -#line 2068 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 300: +#line 2096 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 3); } -#line 7158 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7219 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 298: -#line 2074 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 301: +#line 2102 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 7169 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7230 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 299: -#line 2080 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 302: +#line 2108 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 7180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7241 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 300: -#line 2086 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 303: +#line 2114 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 7191 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7252 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 301: -#line 2092 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 304: +#line 2120 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 7202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7263 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 302: -#line 2098 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 305: +#line 2126 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 7213 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7274 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 303: -#line 2104 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 306: +#line 2132 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 3); } -#line 7224 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7285 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 304: -#line 2110 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 307: +#line 2138 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 4); } -#line 7235 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 305: -#line 2116 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 308: +#line 2144 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 2); } -#line 7246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 306: -#line 2122 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 309: +#line 2150 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 7257 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7318 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 307: -#line 2128 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 310: +#line 2156 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 4); } -#line 7268 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7329 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 308: -#line 2134 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 311: +#line 2162 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 2); } -#line 7279 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7340 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 309: -#line 2140 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 312: +#line 2168 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 3); } -#line 7290 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 310: -#line 2146 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 313: +#line 2174 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 7301 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7362 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 311: -#line 2152 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 314: +#line 2180 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.vulkanRemoved((yyvsp[0].lex).loc, "atomic counter types"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAtomicUint; } -#line 7311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7372 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 312: -#line 2157 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 315: +#line 2185 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D); } -#line 7321 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7382 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 313: -#line 2162 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 316: +#line 2190 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); } -#line 7331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7392 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 314: -#line 2167 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 317: +#line 2195 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd3D); } -#line 7341 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 315: -#line 2172 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 318: +#line 2200 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube); } -#line 7351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7412 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 316: -#line 2177 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 319: +#line 2205 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, false, true); } -#line 7361 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7422 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 317: -#line 2182 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 320: +#line 2210 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, true); } -#line 7371 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7432 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 318: -#line 2187 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 321: +#line 2215 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, false, true); } -#line 7381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7442 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 319: -#line 2192 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 322: +#line 2220 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true); } -#line 7391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 320: -#line 2197 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 323: +#line 2225 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true); } -#line 7401 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7462 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 321: -#line 2202 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 324: +#line 2230 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true, true); } -#line 7411 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7472 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 322: -#line 2207 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 325: +#line 2235 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, true); } -#line 7421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7482 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 323: -#line 2212 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 326: +#line 2240 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true); } -#line 7431 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7492 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 324: -#line 2217 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 327: +#line 2245 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true, true); } -#line 7441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7502 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 325: -#line 2222 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 328: +#line 2250 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7450,11 +7511,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, Esd1D); #endif } -#line 7454 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7515 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 326: -#line 2230 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 329: +#line 2258 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7463,11 +7524,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, Esd2D); #endif } -#line 7467 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7528 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 327: -#line 2238 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 330: +#line 2266 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7476,11 +7537,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, Esd3D); #endif } -#line 7480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7541 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 328: -#line 2246 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 331: +#line 2274 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7489,11 +7550,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, EsdCube); #endif } -#line 7493 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7554 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 329: -#line 2254 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 332: +#line 2282 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7502,11 +7563,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true); #endif } -#line 7506 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 330: -#line 2262 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 333: +#line 2290 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7515,11 +7576,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true); #endif } -#line 7519 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7580 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 331: -#line 2270 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 334: +#line 2298 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7528,11 +7589,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true); #endif } -#line 7532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7593 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 332: -#line 2278 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 335: +#line 2306 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7541,11 +7602,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true); #endif } -#line 7545 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 333: -#line 2286 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 336: +#line 2314 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7554,11 +7615,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true); #endif } -#line 7558 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7619 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 334: -#line 2294 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 337: +#line 2322 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7567,11 +7628,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true); #endif } -#line 7571 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7632 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 335: -#line 2302 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 338: +#line 2330 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7580,11 +7641,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true); #endif } -#line 7584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7645 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 336: -#line 2310 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 339: +#line 2338 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7593,11 +7654,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true); #endif } -#line 7597 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7658 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 337: -#line 2318 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 340: +#line 2346 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7606,171 +7667,171 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true); #endif } -#line 7610 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 338: -#line 2326 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 341: +#line 2354 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd1D); } -#line 7620 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 339: -#line 2331 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 342: +#line 2359 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D); } -#line 7630 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 340: -#line 2336 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 343: +#line 2364 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd3D); } -#line 7640 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7701 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 341: -#line 2341 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 344: +#line 2369 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdCube); } -#line 7650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 342: -#line 2346 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 345: +#line 2374 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd1D, true); } -#line 7660 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7721 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 343: -#line 2351 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 346: +#line 2379 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, true); } -#line 7670 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7731 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 344: -#line 2356 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 347: +#line 2384 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdCube, true); } -#line 7680 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 345: -#line 2361 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 348: +#line 2389 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd1D); } -#line 7690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 346: -#line 2366 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 349: +#line 2394 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D); } -#line 7700 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7761 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 347: -#line 2371 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 350: +#line 2399 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd3D); } -#line 7710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 348: -#line 2376 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 351: +#line 2404 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdCube); } -#line 7720 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7781 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 349: -#line 2381 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 352: +#line 2409 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd1D, true); } -#line 7730 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7791 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 350: -#line 2386 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 353: +#line 2414 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, true); } -#line 7740 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7801 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 351: -#line 2391 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 354: +#line 2419 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdCube, true); } -#line 7750 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7811 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 352: -#line 2396 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 355: +#line 2424 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdRect); } -#line 7760 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7821 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 353: -#line 2401 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 356: +#line 2429 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdRect, false, true); } -#line 7770 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7831 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 354: -#line 2406 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 357: +#line 2434 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7779,11 +7840,11 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, EsdRect); #endif } -#line 7783 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7844 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 355: -#line 2414 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 358: +#line 2442 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7792,41 +7853,41 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true); #endif } -#line 7796 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7857 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 356: -#line 2422 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 359: +#line 2450 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdRect); } -#line 7806 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7867 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 357: -#line 2427 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 360: +#line 2455 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdRect); } -#line 7816 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7877 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 358: -#line 2432 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 361: +#line 2460 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer); } -#line 7826 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7887 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 359: -#line 2437 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 362: +#line 2465 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7835,41 +7896,41 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer); #endif } -#line 7839 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 360: -#line 2445 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 363: +#line 2473 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdBuffer); } -#line 7849 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7910 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 361: -#line 2450 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 364: +#line 2478 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdBuffer); } -#line 7859 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7920 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 362: -#line 2455 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 365: +#line 2483 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, false, true); } -#line 7869 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7930 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 363: -#line 2460 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 366: +#line 2488 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7878,41 +7939,41 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true); #endif } -#line 7882 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7943 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 364: -#line 2468 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 367: +#line 2496 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true); } -#line 7892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 365: -#line 2473 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 368: +#line 2501 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true); } -#line 7902 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7963 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 366: -#line 2478 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 369: +#line 2506 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true); } -#line 7912 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 367: -#line 2483 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 370: +#line 2511 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); @@ -7921,61 +7982,61 @@ yyreduce: (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true); #endif } -#line 7925 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7986 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 368: -#line 2491 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 371: +#line 2519 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, true, false, true); } -#line 7935 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 369: -#line 2496 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 372: +#line 2524 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, true, false, true); } -#line 7945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 370: -#line 2501 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 373: +#line 2529 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setPureSampler(false); } -#line 7955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8016 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 371: -#line 2506 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 374: +#line 2534 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setPureSampler(true); } -#line 7965 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 372: -#line 2511 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 375: +#line 2539 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D); } -#line 7975 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8036 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 373: -#line 2516 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 376: +#line 2544 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -7984,21 +8045,21 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D); #endif } -#line 7988 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8049 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 374: -#line 2524 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 377: +#line 2552 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D); } -#line 7998 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8059 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 375: -#line 2529 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 378: +#line 2557 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8007,21 +8068,21 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D); #endif } -#line 8011 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8072 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 376: -#line 2537 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 379: +#line 2565 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D); } -#line 8021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8082 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 377: -#line 2542 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 380: +#line 2570 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8030,21 +8091,21 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D); #endif } -#line 8034 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8095 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 378: -#line 2550 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 381: +#line 2578 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube); } -#line 8044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8105 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 379: -#line 2555 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 382: +#line 2583 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8053,21 +8114,21 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube); #endif } -#line 8057 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8118 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 380: -#line 2563 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 383: +#line 2591 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D, true); } -#line 8067 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8128 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 381: -#line 2568 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 384: +#line 2596 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8076,21 +8137,21 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true); #endif } -#line 8080 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 382: -#line 2576 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 385: +#line 2604 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true); } -#line 8090 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8151 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 383: -#line 2581 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 386: +#line 2609 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8099,21 +8160,21 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true); #endif } -#line 8103 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8164 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 384: -#line 2589 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 387: +#line 2617 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube, true); } -#line 8113 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8174 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 385: -#line 2594 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 388: +#line 2622 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8122,161 +8183,161 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true); #endif } -#line 8126 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8187 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 386: -#line 2602 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 389: +#line 2630 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D); } -#line 8136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8197 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 387: -#line 2607 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 390: +#line 2635 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D); } -#line 8146 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8207 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 388: -#line 2612 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 391: +#line 2640 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D); } -#line 8156 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8217 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 389: -#line 2617 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 392: +#line 2645 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube); } -#line 8166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8227 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 390: -#line 2622 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 393: +#line 2650 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true); } -#line 8176 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8237 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 391: -#line 2627 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 394: +#line 2655 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true); } -#line 8186 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8247 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 392: -#line 2632 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 395: +#line 2660 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube, true); } -#line 8196 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8257 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 393: -#line 2637 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 396: +#line 2665 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D); } -#line 8206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8267 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 394: -#line 2642 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 397: +#line 2670 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D); } -#line 8216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8277 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 395: -#line 2647 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 398: +#line 2675 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D); } -#line 8226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8287 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 396: -#line 2652 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 399: +#line 2680 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube); } -#line 8236 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8297 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 397: -#line 2657 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 400: +#line 2685 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D, true); } -#line 8246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 398: -#line 2662 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 401: +#line 2690 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true); } -#line 8256 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8317 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 399: -#line 2667 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 402: +#line 2695 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube, true); } -#line 8266 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8327 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 400: -#line 2672 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 403: +#line 2700 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect); } -#line 8276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8337 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 401: -#line 2677 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 404: +#line 2705 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8285,41 +8346,41 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect); #endif } -#line 8289 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8350 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 402: -#line 2685 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 405: +#line 2713 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect); } -#line 8299 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8360 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 403: -#line 2690 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 406: +#line 2718 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect); } -#line 8309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8370 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 404: -#line 2695 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 407: +#line 2723 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer); } -#line 8319 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8380 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 405: -#line 2700 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 408: +#line 2728 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8328,41 +8389,41 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdBuffer); #endif } -#line 8332 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8393 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 406: -#line 2708 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 409: +#line 2736 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer); } -#line 8342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8403 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 407: -#line 2713 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 410: +#line 2741 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer); } -#line 8352 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8413 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 408: -#line 2718 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 411: +#line 2746 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, false, false, true); } -#line 8362 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8423 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 409: -#line 2723 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 412: +#line 2751 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8371,41 +8432,41 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true); #endif } -#line 8375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 410: -#line 2731 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 413: +#line 2759 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, false, false, true); } -#line 8385 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 411: -#line 2736 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 414: +#line 2764 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, false, false, true); } -#line 8395 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 412: -#line 2741 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 415: +#line 2769 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true, false, true); } -#line 8405 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 413: -#line 2746 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 416: +#line 2774 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); @@ -8414,41 +8475,41 @@ yyreduce: (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true); #endif } -#line 8418 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 414: -#line 2754 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 417: +#line 2782 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true, false, true); } -#line 8428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 415: -#line 2759 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 418: +#line 2787 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true, false, true); } -#line 8438 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8499 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 416: -#line 2764 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 419: +#line 2792 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D); } -#line 8448 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8509 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 417: -#line 2769 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 420: +#line 2797 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8457,41 +8518,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D); #endif } -#line 8461 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8522 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 418: -#line 2777 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 421: +#line 2805 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd1D); } -#line 8471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 419: -#line 2782 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 422: +#line 2810 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd1D); } -#line 8481 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8542 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 420: -#line 2787 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 423: +#line 2815 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D); } -#line 8491 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8552 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 421: -#line 2792 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 424: +#line 2820 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8500,41 +8561,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D); #endif } -#line 8504 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8565 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 422: -#line 2800 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 425: +#line 2828 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D); } -#line 8514 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8575 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 423: -#line 2805 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 426: +#line 2833 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D); } -#line 8524 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8585 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 424: -#line 2810 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 427: +#line 2838 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D); } -#line 8534 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8595 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 425: -#line 2815 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 428: +#line 2843 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8543,41 +8604,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D); #endif } -#line 8547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8608 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 426: -#line 2823 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 429: +#line 2851 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd3D); } -#line 8557 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 427: -#line 2828 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 430: +#line 2856 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd3D); } -#line 8567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8628 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 428: -#line 2833 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 431: +#line 2861 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect); } -#line 8577 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 429: -#line 2838 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 432: +#line 2866 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8586,41 +8647,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect); #endif } -#line 8590 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8651 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 430: -#line 2846 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 433: +#line 2874 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdRect); } -#line 8600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 431: -#line 2851 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 434: +#line 2879 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdRect); } -#line 8610 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 432: -#line 2856 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 435: +#line 2884 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube); } -#line 8620 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 433: -#line 2861 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 436: +#line 2889 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8629,41 +8690,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube); #endif } -#line 8633 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8694 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 434: -#line 2869 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 437: +#line 2897 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdCube); } -#line 8643 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8704 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 435: -#line 2874 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 438: +#line 2902 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdCube); } -#line 8653 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8714 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 436: -#line 2879 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 439: +#line 2907 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer); } -#line 8663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8724 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 437: -#line 2884 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 440: +#line 2912 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8672,41 +8733,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer); #endif } -#line 8676 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 438: -#line 2892 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 441: +#line 2920 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer); } -#line 8686 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8747 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 439: -#line 2897 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 442: +#line 2925 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer); } -#line 8696 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8757 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 440: -#line 2902 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 443: +#line 2930 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D, true); } -#line 8706 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8767 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 441: -#line 2907 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 444: +#line 2935 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8715,41 +8776,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true); #endif } -#line 8719 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8780 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 442: -#line 2915 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 445: +#line 2943 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd1D, true); } -#line 8729 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8790 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 443: -#line 2920 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 446: +#line 2948 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd1D, true); } -#line 8739 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8800 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 444: -#line 2925 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 447: +#line 2953 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true); } -#line 8749 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 445: -#line 2930 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 448: +#line 2958 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8758,41 +8819,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true); #endif } -#line 8762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 446: -#line 2938 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 449: +#line 2966 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true); } -#line 8772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 447: -#line 2943 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 450: +#line 2971 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true); } -#line 8782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8843 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 448: -#line 2948 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 451: +#line 2976 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube, true); } -#line 8792 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 449: -#line 2953 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 452: +#line 2981 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8801,41 +8862,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true); #endif } -#line 8805 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8866 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 450: -#line 2961 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 453: +#line 2989 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdCube, true); } -#line 8815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8876 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 451: -#line 2966 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 454: +#line 2994 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdCube, true); } -#line 8825 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8886 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 452: -#line 2971 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 455: +#line 2999 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, false, false, true); } -#line 8835 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8896 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 453: -#line 2976 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 456: +#line 3004 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8844,41 +8905,41 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true); #endif } -#line 8848 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8909 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 454: -#line 2984 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 457: +#line 3012 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, false, false, true); } -#line 8858 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8919 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 455: -#line 2989 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 458: +#line 3017 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, false, false, true); } -#line 8868 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8929 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 456: -#line 2994 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 459: +#line 3022 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true, false, true); } -#line 8878 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8939 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 457: -#line 2999 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 460: +#line 3027 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); @@ -8887,64 +8948,64 @@ yyreduce: (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true); #endif } -#line 8891 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8952 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 458: -#line 3007 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 461: +#line 3035 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true, false, true); } -#line 8901 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 459: -#line 3012 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 462: +#line 3040 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true, false, true); } -#line 8911 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8972 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 460: -#line 3017 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 463: +#line 3045 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // GL_OES_EGL_image_external (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); (yyval.interm.type).sampler.external = true; } -#line 8922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8983 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 461: -#line 3023 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 464: +#line 3051 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat); } -#line 8933 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8994 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 462: -#line 3029 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 465: +#line 3057 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat, true); } -#line 8944 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 463: -#line 3035 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 466: +#line 3063 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); @@ -8954,11 +9015,11 @@ yyreduce: (yyval.interm.type).sampler.setSubpass(EbtFloat16); #endif } -#line 8958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9019 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 464: -#line 3044 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 467: +#line 3072 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { #ifdef AMD_EXTENSIONS parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); @@ -8968,65 +9029,65 @@ yyreduce: (yyval.interm.type).sampler.setSubpass(EbtFloat16, true); #endif } -#line 8972 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9033 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 465: -#line 3053 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 468: +#line 3081 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtInt); } -#line 8983 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 466: -#line 3059 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 469: +#line 3087 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtInt, true); } -#line 8994 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9055 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 467: -#line 3065 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 470: +#line 3093 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtUint); } -#line 9005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 468: -#line 3071 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 471: +#line 3099 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtUint, true); } -#line 9016 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9077 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 469: -#line 3077 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 472: +#line 3105 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary; parseContext.structTypeCheck((yyval.interm.type).loc, (yyval.interm.type)); } -#line 9026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9087 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 470: -#line 3082 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 473: +#line 3110 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // // This is for user defined type names. The lexical phase looked up the @@ -9040,47 +9101,47 @@ yyreduce: } else parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), ""); } -#line 9044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9105 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 471: -#line 3098 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 474: +#line 3126 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "highp precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqHigh); } -#line 9054 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9115 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 472: -#line 3103 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 475: +#line 3131 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqMedium); } -#line 9064 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9125 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 473: -#line 3108 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 476: +#line 3136 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqLow); } -#line 9074 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9135 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 474: -#line 3116 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 477: +#line 3144 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); } -#line 9080 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 475: -#line 3116 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 478: +#line 3144 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string); parseContext.structArrayCheck((yyvsp[-4].lex).loc, *structure); @@ -9092,17 +9153,17 @@ yyreduce: (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 9096 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9157 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 476: -#line 3127 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 479: +#line 3155 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); } -#line 9102 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9163 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 477: -#line 3127 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 480: +#line 3155 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { TType* structure = new TType((yyvsp[-1].interm.typeList), TString("")); (yyval.interm.type).init((yyvsp[-4].lex).loc); @@ -9110,19 +9171,19 @@ yyreduce: (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 9114 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 478: -#line 3137 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 481: +#line 3165 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList) = (yyvsp[0].interm.typeList); } -#line 9122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9183 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 479: -#line 3140 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 482: +#line 3168 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) { @@ -9133,11 +9194,11 @@ yyreduce: (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]); } } -#line 9137 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9198 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 480: -#line 3153 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 483: +#line 3181 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -9160,11 +9221,11 @@ yyreduce: (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 9164 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9225 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 481: -#line 3175 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 484: +#line 3203 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -9189,38 +9250,38 @@ yyreduce: (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 9193 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9254 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 482: -#line 3202 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 485: +#line 3230 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList) = new TTypeList; (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 9202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9263 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 483: -#line 3206 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 486: +#line 3234 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 9210 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9271 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 484: -#line 3212 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 487: +#line 3240 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeLine).type = new TType(EbtVoid); (yyval.interm.typeLine).loc = (yyvsp[0].lex).loc; (yyval.interm.typeLine).type->setFieldName(*(yyvsp[0].lex).string); } -#line 9220 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9281 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 485: -#line 3217 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 488: +#line 3245 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes); @@ -9229,219 +9290,219 @@ yyreduce: (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string); (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes); } -#line 9233 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9294 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 486: -#line 3228 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 489: +#line 3256 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 9241 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9302 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 487: -#line 3231 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 490: +#line 3259 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { const char* initFeature = "{ } style initializers"; parseContext.requireProfile((yyvsp[-2].lex).loc, ~EEsProfile, initFeature); parseContext.profileRequires((yyvsp[-2].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); } -#line 9252 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9313 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 488: -#line 3237 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 491: +#line 3265 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { const char* initFeature = "{ } style initializers"; parseContext.requireProfile((yyvsp[-3].lex).loc, ~EEsProfile, initFeature); parseContext.profileRequires((yyvsp[-3].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 9263 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 489: -#line 3246 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc()); - } -#line 9271 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 490: -#line 3249 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); - } -#line 9279 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 491: -#line 3255 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9285 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9324 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 492: -#line 3259 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9291 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3274 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc()); + } +#line 9332 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 493: -#line 3260 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9297 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3277 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); + } +#line 9340 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 494: -#line 3266 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3283 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9303 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9346 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 495: -#line 3267 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3287 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9352 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 496: -#line 3268 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3288 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9315 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9358 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 497: -#line 3269 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3294 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9321 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 498: -#line 3270 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3295 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9327 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9370 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 499: -#line 3271 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3296 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 500: -#line 3272 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3297 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9339 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9382 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 501: -#line 3276 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = 0; } -#line 9345 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 3298 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9388 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 502: -#line 3277 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3299 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9394 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 503: +#line 3300 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9400 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 504: +#line 3304 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = 0; } +#line 9406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 505: +#line 3305 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; } -#line 9354 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9415 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 503: -#line 3281 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 506: +#line 3309 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; } -#line 9363 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9424 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 504: -#line 3285 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 507: +#line 3313 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate()) (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode); } -#line 9373 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 505: -#line 3293 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9379 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 506: -#line 3294 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9385 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 507: -#line 3298 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - ++parseContext.controlFlowNestingLevel; - } -#line 9393 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9434 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 508: -#line 3301 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3321 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9440 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 509: +#line 3322 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 510: +#line 3326 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + ++parseContext.controlFlowNestingLevel; + } +#line 9454 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 511: +#line 3329 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 509: -#line 3305 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 512: +#line 3333 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 9412 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9473 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 510: -#line 3310 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 513: +#line 3338 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9423 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9484 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 511: -#line 3319 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 514: +#line 3347 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; } -#line 9431 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9492 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 512: -#line 3322 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 515: +#line 3350 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate()) (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode); } -#line 9441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9502 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 513: -#line 3330 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 516: +#line 3358 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || @@ -9450,11 +9511,11 @@ yyreduce: (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case } } -#line 9454 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9515 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 514: -#line 3338 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 517: +#line 3366 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) { @@ -9463,76 +9524,76 @@ yyreduce: } else (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 9467 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 515: -#line 3349 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = 0; } -#line 9473 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 516: -#line 3350 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = static_cast((yyvsp[-1].interm.intermTypedNode)); } -#line 9479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 517: -#line 3354 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); - } -#line 9487 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9528 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 518: -#line 3357 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3377 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = 0; } +#line 9534 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 519: +#line 3378 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = static_cast((yyvsp[-1].interm.intermTypedNode)); } +#line 9540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 520: +#line 3382 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); + } +#line 9548 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 521: +#line 3385 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9557 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 519: -#line 3363 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 522: +#line 3391 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-2].interm.intermTypedNode)); (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yyvsp[-4].lex).loc); } -#line 9505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 520: -#line 3370 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 523: +#line 3398 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode); } -#line 9514 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9575 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 521: -#line 3374 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 524: +#line 3402 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode); (yyval.interm.nodePair).node2 = 0; } -#line 9523 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 522: -#line 3382 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 525: +#line 3410 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)); } -#line 9532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9593 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 523: -#line 3386 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 526: +#line 3414 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type)); @@ -9543,28 +9604,28 @@ yyreduce: else (yyval.interm.intermTypedNode) = 0; } -#line 9547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9608 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 524: -#line 3399 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 527: +#line 3427 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9555 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9616 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 525: -#line 3402 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 528: +#line 3430 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9564 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9625 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 526: -#line 3408 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 529: +#line 3436 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // start new switch sequence on the switch stack ++parseContext.controlFlowNestingLevel; @@ -9573,11 +9634,11 @@ yyreduce: parseContext.switchLevel.push_back(parseContext.statementNestingLevel); parseContext.symbolTable.push(); } -#line 9577 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 527: -#line 3416 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 530: +#line 3444 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[-7].lex).loc, (yyvsp[-5].interm.intermTypedNode), (yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0); delete parseContext.switchSequenceStack.back(); @@ -9587,27 +9648,27 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 9591 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9652 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 528: -#line 3428 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 531: +#line 3456 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; } -#line 9599 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9660 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 529: -#line 3431 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 532: +#line 3459 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9607 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 530: -#line 3437 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 533: +#line 3465 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -9620,11 +9681,11 @@ yyreduce: (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc); } } -#line 9624 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9685 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 531: -#line 3449 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 534: +#line 3477 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -9634,28 +9695,28 @@ yyreduce: else (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc); } -#line 9638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9699 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 532: -#line 3461 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 535: +#line 3489 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9646 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9707 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 533: -#line 3464 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 536: +#line 3492 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9655 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9716 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 534: -#line 3470 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 537: +#line 3498 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", ""); @@ -9664,11 +9725,11 @@ yyreduce: ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 9668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9729 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 535: -#line 3478 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 538: +#line 3506 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, true, (yyvsp[-5].lex).loc); @@ -9676,21 +9737,21 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 9680 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 536: -#line 3485 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 539: +#line 3513 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 9690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 537: -#line 3490 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 540: +#line 3518 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", ""); @@ -9702,22 +9763,22 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 9706 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9767 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 538: -#line 3501 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 541: +#line 3529 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.push(); ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 9717 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9778 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 539: -#line 3507 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 542: +#line 3535 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc); @@ -9730,81 +9791,81 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 9734 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 540: -#line 3522 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); - } -#line 9742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 541: -#line 3525 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); - } -#line 9750 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 542: -#line 3531 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); - } -#line 9758 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 543: -#line 3534 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3550 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { - (yyval.interm.intermTypedNode) = 0; + (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9766 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9803 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 544: -#line 3540 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3553 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); + } +#line 9811 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 545: +#line 3559 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); + } +#line 9819 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 546: +#line 3562 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.intermTypedNode) = 0; + } +#line 9827 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 547: +#line 3568 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode); (yyval.interm.nodePair).node2 = 0; } -#line 9775 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9836 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 545: -#line 3544 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 548: +#line 3572 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode); } -#line 9784 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9845 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 546: -#line 3551 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 549: +#line 3579 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if (parseContext.loopNestingLevel <= 0) parseContext.error((yyvsp[-1].lex).loc, "continue statement only allowed in loops", "", ""); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpContinue, (yyvsp[-1].lex).loc); } -#line 9794 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9855 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 547: -#line 3556 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 550: +#line 3584 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0) parseContext.error((yyvsp[-1].lex).loc, "break statement only allowed in switch and loops", "", ""); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpBreak, (yyvsp[-1].lex).loc); } -#line 9804 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9865 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 548: -#line 3561 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 551: +#line 3589 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc); if (parseContext.currentFunctionType->getBasicType() != EbtVoid) @@ -9812,83 +9873,83 @@ yyreduce: if (parseContext.inMain) parseContext.postEntryPointReturn = true; } -#line 9816 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9877 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 549: -#line 3568 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 552: +#line 3596 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode)); } -#line 9824 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 550: -#line 3571 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 553: +#line 3599 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc); } -#line 9833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9894 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 551: -#line 3580 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 554: +#line 3608 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } -#line 9842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9903 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 552: -#line 3584 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 555: +#line 3612 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { if ((yyvsp[0].interm.intermNode) != nullptr) { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } } -#line 9853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9914 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 553: -#line 3593 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 556: +#line 3621 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9861 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 554: -#line 3596 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 557: +#line 3624 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9869 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9930 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 555: -#line 3599 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 558: +#line 3627 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "extraneous semicolon"); parseContext.profileRequires((yyvsp[0].lex).loc, ~EEsProfile, 460, nullptr, "extraneous semicolon"); (yyval.interm.intermNode) = nullptr; } -#line 9879 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 556: -#line 3607 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 559: +#line 3635 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyvsp[0].interm).function = parseContext.handleFunctionDeclarator((yyvsp[0].interm).loc, *(yyvsp[0].interm).function, false /* not prototype */); (yyvsp[0].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[0].interm).loc, *(yyvsp[0].interm).function); } -#line 9888 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 557: -#line 3611 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 560: +#line 3639 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { // May be best done as post process phase on intermediate code if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue) @@ -9904,52 +9965,52 @@ yyreduce: (yyval.interm.intermNode)->getAsAggregate()->setDebug(parseContext.contextPragma.debug); (yyval.interm.intermNode)->getAsAggregate()->setPragmaTable(parseContext.contextPragma.pragmaTable); } -#line 9908 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9969 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; - case 558: -#line 3629 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 561: +#line 3657 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.attributes) = (yyvsp[-2].interm.attributes); parseContext.requireExtensions((yyvsp[-4].lex).loc, 1, &E_GL_EXT_control_flow_attributes, "attribute"); } -#line 9917 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 559: -#line 3635 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.attributes) = (yyvsp[0].interm.attributes); - } -#line 9925 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 560: -#line 3638 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes)); - } -#line 9933 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 561: -#line 3643 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { - (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string); - } -#line 9941 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9978 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; case 562: -#line 3646 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3663 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.attributes) = (yyvsp[0].interm.attributes); + } +#line 9986 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 563: +#line 3666 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes)); + } +#line 9994 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 564: +#line 3671 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string); + } +#line 10002 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 565: +#line 3674 "MachineIndependent/glslang.y" /* yacc.c:1646 */ { (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode)); } -#line 9949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10010 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ break; -#line 9953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10014 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -10177,5 +10238,5 @@ yyreturn: #endif return yyresult; } -#line 3650 "MachineIndependent/glslang.y" /* yacc.c:1906 */ +#line 3678 "MachineIndependent/glslang.y" /* yacc.c:1906 */ diff --git a/glslang/MachineIndependent/glslang_tab.cpp.h b/glslang/MachineIndependent/glslang_tab.cpp.h index a5f39149f..d8111f807 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp.h +++ b/glslang/MachineIndependent/glslang_tab.cpp.h @@ -165,280 +165,283 @@ extern int yydebug; LAYOUT = 375, EXPLICITINTERPAMD = 376, PERVERTEXNV = 377, - MAT2X2 = 378, - MAT2X3 = 379, - MAT2X4 = 380, - MAT3X2 = 381, - MAT3X3 = 382, - MAT3X4 = 383, - MAT4X2 = 384, - MAT4X3 = 385, - MAT4X4 = 386, - DMAT2X2 = 387, - DMAT2X3 = 388, - DMAT2X4 = 389, - DMAT3X2 = 390, - DMAT3X3 = 391, - DMAT3X4 = 392, - DMAT4X2 = 393, - DMAT4X3 = 394, - DMAT4X4 = 395, - F16MAT2X2 = 396, - F16MAT2X3 = 397, - F16MAT2X4 = 398, - F16MAT3X2 = 399, - F16MAT3X3 = 400, - F16MAT3X4 = 401, - F16MAT4X2 = 402, - F16MAT4X3 = 403, - F16MAT4X4 = 404, - F32MAT2X2 = 405, - F32MAT2X3 = 406, - F32MAT2X4 = 407, - F32MAT3X2 = 408, - F32MAT3X3 = 409, - F32MAT3X4 = 410, - F32MAT4X2 = 411, - F32MAT4X3 = 412, - F32MAT4X4 = 413, - F64MAT2X2 = 414, - F64MAT2X3 = 415, - F64MAT2X4 = 416, - F64MAT3X2 = 417, - F64MAT3X3 = 418, - F64MAT3X4 = 419, - F64MAT4X2 = 420, - F64MAT4X3 = 421, - F64MAT4X4 = 422, - ATOMIC_UINT = 423, - SAMPLER1D = 424, - SAMPLER2D = 425, - SAMPLER3D = 426, - SAMPLERCUBE = 427, - SAMPLER1DSHADOW = 428, - SAMPLER2DSHADOW = 429, - SAMPLERCUBESHADOW = 430, - SAMPLER1DARRAY = 431, - SAMPLER2DARRAY = 432, - SAMPLER1DARRAYSHADOW = 433, - SAMPLER2DARRAYSHADOW = 434, - ISAMPLER1D = 435, - ISAMPLER2D = 436, - ISAMPLER3D = 437, - ISAMPLERCUBE = 438, - ISAMPLER1DARRAY = 439, - ISAMPLER2DARRAY = 440, - USAMPLER1D = 441, - USAMPLER2D = 442, - USAMPLER3D = 443, - USAMPLERCUBE = 444, - USAMPLER1DARRAY = 445, - USAMPLER2DARRAY = 446, - SAMPLER2DRECT = 447, - SAMPLER2DRECTSHADOW = 448, - ISAMPLER2DRECT = 449, - USAMPLER2DRECT = 450, - SAMPLERBUFFER = 451, - ISAMPLERBUFFER = 452, - USAMPLERBUFFER = 453, - SAMPLERCUBEARRAY = 454, - SAMPLERCUBEARRAYSHADOW = 455, - ISAMPLERCUBEARRAY = 456, - USAMPLERCUBEARRAY = 457, - SAMPLER2DMS = 458, - ISAMPLER2DMS = 459, - USAMPLER2DMS = 460, - SAMPLER2DMSARRAY = 461, - ISAMPLER2DMSARRAY = 462, - USAMPLER2DMSARRAY = 463, - SAMPLEREXTERNALOES = 464, - F16SAMPLER1D = 465, - F16SAMPLER2D = 466, - F16SAMPLER3D = 467, - F16SAMPLER2DRECT = 468, - F16SAMPLERCUBE = 469, - F16SAMPLER1DARRAY = 470, - F16SAMPLER2DARRAY = 471, - F16SAMPLERCUBEARRAY = 472, - F16SAMPLERBUFFER = 473, - F16SAMPLER2DMS = 474, - F16SAMPLER2DMSARRAY = 475, - F16SAMPLER1DSHADOW = 476, - F16SAMPLER2DSHADOW = 477, - F16SAMPLER1DARRAYSHADOW = 478, - F16SAMPLER2DARRAYSHADOW = 479, - F16SAMPLER2DRECTSHADOW = 480, - F16SAMPLERCUBESHADOW = 481, - F16SAMPLERCUBEARRAYSHADOW = 482, - SAMPLER = 483, - SAMPLERSHADOW = 484, - TEXTURE1D = 485, - TEXTURE2D = 486, - TEXTURE3D = 487, - TEXTURECUBE = 488, - TEXTURE1DARRAY = 489, - TEXTURE2DARRAY = 490, - ITEXTURE1D = 491, - ITEXTURE2D = 492, - ITEXTURE3D = 493, - ITEXTURECUBE = 494, - ITEXTURE1DARRAY = 495, - ITEXTURE2DARRAY = 496, - UTEXTURE1D = 497, - UTEXTURE2D = 498, - UTEXTURE3D = 499, - UTEXTURECUBE = 500, - UTEXTURE1DARRAY = 501, - UTEXTURE2DARRAY = 502, - TEXTURE2DRECT = 503, - ITEXTURE2DRECT = 504, - UTEXTURE2DRECT = 505, - TEXTUREBUFFER = 506, - ITEXTUREBUFFER = 507, - UTEXTUREBUFFER = 508, - TEXTURECUBEARRAY = 509, - ITEXTURECUBEARRAY = 510, - UTEXTURECUBEARRAY = 511, - TEXTURE2DMS = 512, - ITEXTURE2DMS = 513, - UTEXTURE2DMS = 514, - TEXTURE2DMSARRAY = 515, - ITEXTURE2DMSARRAY = 516, - UTEXTURE2DMSARRAY = 517, - F16TEXTURE1D = 518, - F16TEXTURE2D = 519, - F16TEXTURE3D = 520, - F16TEXTURE2DRECT = 521, - F16TEXTURECUBE = 522, - F16TEXTURE1DARRAY = 523, - F16TEXTURE2DARRAY = 524, - F16TEXTURECUBEARRAY = 525, - F16TEXTUREBUFFER = 526, - F16TEXTURE2DMS = 527, - F16TEXTURE2DMSARRAY = 528, - SUBPASSINPUT = 529, - SUBPASSINPUTMS = 530, - ISUBPASSINPUT = 531, - ISUBPASSINPUTMS = 532, - USUBPASSINPUT = 533, - USUBPASSINPUTMS = 534, - F16SUBPASSINPUT = 535, - F16SUBPASSINPUTMS = 536, - IMAGE1D = 537, - IIMAGE1D = 538, - UIMAGE1D = 539, - IMAGE2D = 540, - IIMAGE2D = 541, - UIMAGE2D = 542, - IMAGE3D = 543, - IIMAGE3D = 544, - UIMAGE3D = 545, - IMAGE2DRECT = 546, - IIMAGE2DRECT = 547, - UIMAGE2DRECT = 548, - IMAGECUBE = 549, - IIMAGECUBE = 550, - UIMAGECUBE = 551, - IMAGEBUFFER = 552, - IIMAGEBUFFER = 553, - UIMAGEBUFFER = 554, - IMAGE1DARRAY = 555, - IIMAGE1DARRAY = 556, - UIMAGE1DARRAY = 557, - IMAGE2DARRAY = 558, - IIMAGE2DARRAY = 559, - UIMAGE2DARRAY = 560, - IMAGECUBEARRAY = 561, - IIMAGECUBEARRAY = 562, - UIMAGECUBEARRAY = 563, - IMAGE2DMS = 564, - IIMAGE2DMS = 565, - UIMAGE2DMS = 566, - IMAGE2DMSARRAY = 567, - IIMAGE2DMSARRAY = 568, - UIMAGE2DMSARRAY = 569, - F16IMAGE1D = 570, - F16IMAGE2D = 571, - F16IMAGE3D = 572, - F16IMAGE2DRECT = 573, - F16IMAGECUBE = 574, - F16IMAGE1DARRAY = 575, - F16IMAGE2DARRAY = 576, - F16IMAGECUBEARRAY = 577, - F16IMAGEBUFFER = 578, - F16IMAGE2DMS = 579, - F16IMAGE2DMSARRAY = 580, - STRUCT = 581, - VOID = 582, - WHILE = 583, - IDENTIFIER = 584, - TYPE_NAME = 585, - FLOATCONSTANT = 586, - DOUBLECONSTANT = 587, - INT16CONSTANT = 588, - UINT16CONSTANT = 589, - INT32CONSTANT = 590, - UINT32CONSTANT = 591, - INTCONSTANT = 592, - UINTCONSTANT = 593, - INT64CONSTANT = 594, - UINT64CONSTANT = 595, - BOOLCONSTANT = 596, - FLOAT16CONSTANT = 597, - LEFT_OP = 598, - RIGHT_OP = 599, - INC_OP = 600, - DEC_OP = 601, - LE_OP = 602, - GE_OP = 603, - EQ_OP = 604, - NE_OP = 605, - AND_OP = 606, - OR_OP = 607, - XOR_OP = 608, - MUL_ASSIGN = 609, - DIV_ASSIGN = 610, - ADD_ASSIGN = 611, - MOD_ASSIGN = 612, - LEFT_ASSIGN = 613, - RIGHT_ASSIGN = 614, - AND_ASSIGN = 615, - XOR_ASSIGN = 616, - OR_ASSIGN = 617, - SUB_ASSIGN = 618, - LEFT_PAREN = 619, - RIGHT_PAREN = 620, - LEFT_BRACKET = 621, - RIGHT_BRACKET = 622, - LEFT_BRACE = 623, - RIGHT_BRACE = 624, - DOT = 625, - COMMA = 626, - COLON = 627, - EQUAL = 628, - SEMICOLON = 629, - BANG = 630, - DASH = 631, - TILDE = 632, - PLUS = 633, - STAR = 634, - SLASH = 635, - PERCENT = 636, - LEFT_ANGLE = 637, - RIGHT_ANGLE = 638, - VERTICAL_BAR = 639, - CARET = 640, - AMPERSAND = 641, - QUESTION = 642, - INVARIANT = 643, - PRECISE = 644, - HIGH_PRECISION = 645, - MEDIUM_PRECISION = 646, - LOW_PRECISION = 647, - PRECISION = 648, - PACKED = 649, - RESOURCE = 650, - SUPERP = 651 + PERPRIMITIVENV = 378, + PERVIEWNV = 379, + PERTASKNV = 380, + MAT2X2 = 381, + MAT2X3 = 382, + MAT2X4 = 383, + MAT3X2 = 384, + MAT3X3 = 385, + MAT3X4 = 386, + MAT4X2 = 387, + MAT4X3 = 388, + MAT4X4 = 389, + DMAT2X2 = 390, + DMAT2X3 = 391, + DMAT2X4 = 392, + DMAT3X2 = 393, + DMAT3X3 = 394, + DMAT3X4 = 395, + DMAT4X2 = 396, + DMAT4X3 = 397, + DMAT4X4 = 398, + F16MAT2X2 = 399, + F16MAT2X3 = 400, + F16MAT2X4 = 401, + F16MAT3X2 = 402, + F16MAT3X3 = 403, + F16MAT3X4 = 404, + F16MAT4X2 = 405, + F16MAT4X3 = 406, + F16MAT4X4 = 407, + F32MAT2X2 = 408, + F32MAT2X3 = 409, + F32MAT2X4 = 410, + F32MAT3X2 = 411, + F32MAT3X3 = 412, + F32MAT3X4 = 413, + F32MAT4X2 = 414, + F32MAT4X3 = 415, + F32MAT4X4 = 416, + F64MAT2X2 = 417, + F64MAT2X3 = 418, + F64MAT2X4 = 419, + F64MAT3X2 = 420, + F64MAT3X3 = 421, + F64MAT3X4 = 422, + F64MAT4X2 = 423, + F64MAT4X3 = 424, + F64MAT4X4 = 425, + ATOMIC_UINT = 426, + SAMPLER1D = 427, + SAMPLER2D = 428, + SAMPLER3D = 429, + SAMPLERCUBE = 430, + SAMPLER1DSHADOW = 431, + SAMPLER2DSHADOW = 432, + SAMPLERCUBESHADOW = 433, + SAMPLER1DARRAY = 434, + SAMPLER2DARRAY = 435, + SAMPLER1DARRAYSHADOW = 436, + SAMPLER2DARRAYSHADOW = 437, + ISAMPLER1D = 438, + ISAMPLER2D = 439, + ISAMPLER3D = 440, + ISAMPLERCUBE = 441, + ISAMPLER1DARRAY = 442, + ISAMPLER2DARRAY = 443, + USAMPLER1D = 444, + USAMPLER2D = 445, + USAMPLER3D = 446, + USAMPLERCUBE = 447, + USAMPLER1DARRAY = 448, + USAMPLER2DARRAY = 449, + SAMPLER2DRECT = 450, + SAMPLER2DRECTSHADOW = 451, + ISAMPLER2DRECT = 452, + USAMPLER2DRECT = 453, + SAMPLERBUFFER = 454, + ISAMPLERBUFFER = 455, + USAMPLERBUFFER = 456, + SAMPLERCUBEARRAY = 457, + SAMPLERCUBEARRAYSHADOW = 458, + ISAMPLERCUBEARRAY = 459, + USAMPLERCUBEARRAY = 460, + SAMPLER2DMS = 461, + ISAMPLER2DMS = 462, + USAMPLER2DMS = 463, + SAMPLER2DMSARRAY = 464, + ISAMPLER2DMSARRAY = 465, + USAMPLER2DMSARRAY = 466, + SAMPLEREXTERNALOES = 467, + F16SAMPLER1D = 468, + F16SAMPLER2D = 469, + F16SAMPLER3D = 470, + F16SAMPLER2DRECT = 471, + F16SAMPLERCUBE = 472, + F16SAMPLER1DARRAY = 473, + F16SAMPLER2DARRAY = 474, + F16SAMPLERCUBEARRAY = 475, + F16SAMPLERBUFFER = 476, + F16SAMPLER2DMS = 477, + F16SAMPLER2DMSARRAY = 478, + F16SAMPLER1DSHADOW = 479, + F16SAMPLER2DSHADOW = 480, + F16SAMPLER1DARRAYSHADOW = 481, + F16SAMPLER2DARRAYSHADOW = 482, + F16SAMPLER2DRECTSHADOW = 483, + F16SAMPLERCUBESHADOW = 484, + F16SAMPLERCUBEARRAYSHADOW = 485, + SAMPLER = 486, + SAMPLERSHADOW = 487, + TEXTURE1D = 488, + TEXTURE2D = 489, + TEXTURE3D = 490, + TEXTURECUBE = 491, + TEXTURE1DARRAY = 492, + TEXTURE2DARRAY = 493, + ITEXTURE1D = 494, + ITEXTURE2D = 495, + ITEXTURE3D = 496, + ITEXTURECUBE = 497, + ITEXTURE1DARRAY = 498, + ITEXTURE2DARRAY = 499, + UTEXTURE1D = 500, + UTEXTURE2D = 501, + UTEXTURE3D = 502, + UTEXTURECUBE = 503, + UTEXTURE1DARRAY = 504, + UTEXTURE2DARRAY = 505, + TEXTURE2DRECT = 506, + ITEXTURE2DRECT = 507, + UTEXTURE2DRECT = 508, + TEXTUREBUFFER = 509, + ITEXTUREBUFFER = 510, + UTEXTUREBUFFER = 511, + TEXTURECUBEARRAY = 512, + ITEXTURECUBEARRAY = 513, + UTEXTURECUBEARRAY = 514, + TEXTURE2DMS = 515, + ITEXTURE2DMS = 516, + UTEXTURE2DMS = 517, + TEXTURE2DMSARRAY = 518, + ITEXTURE2DMSARRAY = 519, + UTEXTURE2DMSARRAY = 520, + F16TEXTURE1D = 521, + F16TEXTURE2D = 522, + F16TEXTURE3D = 523, + F16TEXTURE2DRECT = 524, + F16TEXTURECUBE = 525, + F16TEXTURE1DARRAY = 526, + F16TEXTURE2DARRAY = 527, + F16TEXTURECUBEARRAY = 528, + F16TEXTUREBUFFER = 529, + F16TEXTURE2DMS = 530, + F16TEXTURE2DMSARRAY = 531, + SUBPASSINPUT = 532, + SUBPASSINPUTMS = 533, + ISUBPASSINPUT = 534, + ISUBPASSINPUTMS = 535, + USUBPASSINPUT = 536, + USUBPASSINPUTMS = 537, + F16SUBPASSINPUT = 538, + F16SUBPASSINPUTMS = 539, + IMAGE1D = 540, + IIMAGE1D = 541, + UIMAGE1D = 542, + IMAGE2D = 543, + IIMAGE2D = 544, + UIMAGE2D = 545, + IMAGE3D = 546, + IIMAGE3D = 547, + UIMAGE3D = 548, + IMAGE2DRECT = 549, + IIMAGE2DRECT = 550, + UIMAGE2DRECT = 551, + IMAGECUBE = 552, + IIMAGECUBE = 553, + UIMAGECUBE = 554, + IMAGEBUFFER = 555, + IIMAGEBUFFER = 556, + UIMAGEBUFFER = 557, + IMAGE1DARRAY = 558, + IIMAGE1DARRAY = 559, + UIMAGE1DARRAY = 560, + IMAGE2DARRAY = 561, + IIMAGE2DARRAY = 562, + UIMAGE2DARRAY = 563, + IMAGECUBEARRAY = 564, + IIMAGECUBEARRAY = 565, + UIMAGECUBEARRAY = 566, + IMAGE2DMS = 567, + IIMAGE2DMS = 568, + UIMAGE2DMS = 569, + IMAGE2DMSARRAY = 570, + IIMAGE2DMSARRAY = 571, + UIMAGE2DMSARRAY = 572, + F16IMAGE1D = 573, + F16IMAGE2D = 574, + F16IMAGE3D = 575, + F16IMAGE2DRECT = 576, + F16IMAGECUBE = 577, + F16IMAGE1DARRAY = 578, + F16IMAGE2DARRAY = 579, + F16IMAGECUBEARRAY = 580, + F16IMAGEBUFFER = 581, + F16IMAGE2DMS = 582, + F16IMAGE2DMSARRAY = 583, + STRUCT = 584, + VOID = 585, + WHILE = 586, + IDENTIFIER = 587, + TYPE_NAME = 588, + FLOATCONSTANT = 589, + DOUBLECONSTANT = 590, + INT16CONSTANT = 591, + UINT16CONSTANT = 592, + INT32CONSTANT = 593, + UINT32CONSTANT = 594, + INTCONSTANT = 595, + UINTCONSTANT = 596, + INT64CONSTANT = 597, + UINT64CONSTANT = 598, + BOOLCONSTANT = 599, + FLOAT16CONSTANT = 600, + LEFT_OP = 601, + RIGHT_OP = 602, + INC_OP = 603, + DEC_OP = 604, + LE_OP = 605, + GE_OP = 606, + EQ_OP = 607, + NE_OP = 608, + AND_OP = 609, + OR_OP = 610, + XOR_OP = 611, + MUL_ASSIGN = 612, + DIV_ASSIGN = 613, + ADD_ASSIGN = 614, + MOD_ASSIGN = 615, + LEFT_ASSIGN = 616, + RIGHT_ASSIGN = 617, + AND_ASSIGN = 618, + XOR_ASSIGN = 619, + OR_ASSIGN = 620, + SUB_ASSIGN = 621, + LEFT_PAREN = 622, + RIGHT_PAREN = 623, + LEFT_BRACKET = 624, + RIGHT_BRACKET = 625, + LEFT_BRACE = 626, + RIGHT_BRACE = 627, + DOT = 628, + COMMA = 629, + COLON = 630, + EQUAL = 631, + SEMICOLON = 632, + BANG = 633, + DASH = 634, + TILDE = 635, + PLUS = 636, + STAR = 637, + SLASH = 638, + PERCENT = 639, + LEFT_ANGLE = 640, + RIGHT_ANGLE = 641, + VERTICAL_BAR = 642, + CARET = 643, + AMPERSAND = 644, + QUESTION = 645, + INVARIANT = 646, + PRECISE = 647, + HIGH_PRECISION = 648, + MEDIUM_PRECISION = 649, + LOW_PRECISION = 650, + PRECISION = 651, + PACKED = 652, + RESOURCE = 653, + SUPERP = 654 }; #endif @@ -482,7 +485,7 @@ union YYSTYPE }; } interm; -#line 486 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909 */ +#line 489 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909 */ }; typedef union YYSTYPE YYSTYPE; diff --git a/glslang/MachineIndependent/intermOut.cpp b/glslang/MachineIndependent/intermOut.cpp index 70c986b4d..a37122fba 100644 --- a/glslang/MachineIndependent/intermOut.cpp +++ b/glslang/MachineIndependent/intermOut.cpp @@ -1048,6 +1048,10 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpSubpassLoad: out.debug << "subpassLoad"; break; case EOpSubpassLoadMS: out.debug << "subpassLoadMS"; break; +#ifdef NV_EXTENSIONS + case EOpWritePackedPrimitiveIndices4x8NV: out.debug << "writePackedPrimitiveIndices4x8NV"; break; +#endif + default: out.debug.message(EPrefixError, "Bad aggregation op"); } @@ -1451,6 +1455,16 @@ void TIntermediate::output(TInfoSink& infoSink, bool tree) } break; +#ifdef NV_EXTENSIONS + case EShLangMeshNV: + infoSink.debug << "max_vertices = " << vertices << "\n"; + infoSink.debug << "max_primitives = " << primitives << "\n"; + infoSink.debug << "output primitive = " << TQualifier::getGeometryString(outputPrimitive) << "\n"; + // Fall through + + case EShLangTaskNV: + // Fall through +#endif case EShLangCompute: infoSink.debug << "local_size = (" << localSize[0] << ", " << localSize[1] << ", " << localSize[2] << ")\n"; { diff --git a/glslang/MachineIndependent/linkValidate.cpp b/glslang/MachineIndependent/linkValidate.cpp index 4c89c8bf3..5ddda5896 100644 --- a/glslang/MachineIndependent/linkValidate.cpp +++ b/glslang/MachineIndependent/linkValidate.cpp @@ -141,13 +141,27 @@ void TIntermediate::mergeModes(TInfoSink& infoSink, TIntermediate& unit) if (vertices == TQualifier::layoutNotSet) vertices = unit.vertices; else if (vertices != unit.vertices) { - if (language == EShLangGeometry) + if (language == EShLangGeometry +#ifdef NV_EXTENSIONS + || language == EShLangMeshNV +#endif + ) error(infoSink, "Contradictory layout max_vertices values"); else if (language == EShLangTessControl) error(infoSink, "Contradictory layout vertices values"); else assert(0); } +#ifdef NV_EXTENSIONS + if (primitives == TQualifier::layoutNotSet) + primitives = unit.primitives; + else if (primitives != unit.primitives) { + if (language == EShLangMeshNV) + error(infoSink, "Contradictory layout max_primitives values"); + else + assert(0); + } +#endif if (inputPrimitive == ElgNone) inputPrimitive = unit.inputPrimitive; @@ -266,6 +280,10 @@ void TIntermediate::mergeTrees(TInfoSink& infoSink, TIntermediate& unit) // Getting this far means we have two existing trees to merge... +#ifdef NV_EXTENSIONS + numTaskNVBlocks += unit.numTaskNVBlocks; +#endif + // Get the top-level globals of each unit TIntermSequence& globals = treeRoot->getAsAggregate()->getSequence(); TIntermSequence& unitGlobals = unit.treeRoot->getAsAggregate()->getSequence(); @@ -690,6 +708,22 @@ void TIntermediate::finalCheck(TInfoSink& infoSink, bool keepUncalled) break; case EShLangCompute: break; + +#ifdef NV_EXTENSIONS + case EShLangMeshNV: + if (outputPrimitive == ElgNone) + error(infoSink, "At least one shader must specify an output layout primitive"); + if (vertices == TQualifier::layoutNotSet) + error(infoSink, "At least one shader must specify a layout(max_vertices = value)"); + if (primitives == TQualifier::layoutNotSet) + error(infoSink, "At least one shader must specify a layout(max_primitives = value)"); + // fall through + case EShLangTaskNV: + if (numTaskNVBlocks > 1) + error(infoSink, "Only one taskNV interface block is allowed per shader"); + break; +#endif + default: error(infoSink, "Unknown Stage."); break; @@ -960,7 +994,7 @@ int TIntermediate::addUsedLocation(const TQualifier& qualifier, const TType& typ return -1; int size; - if (qualifier.isUniformOrBuffer()) { + if (qualifier.isUniformOrBuffer() || qualifier.isTaskMemory()) { if (type.isSizedArray()) size = type.getCumulativeArraySize(); else @@ -1111,10 +1145,19 @@ int TIntermediate::computeTypeLocationSize(const TType& type, EShLanguage stage) // TODO: perf: this can be flattened by using getCumulativeArraySize(), and a deref that discards all arrayness // TODO: are there valid cases of having an unsized array with a location? If so, running this code too early. TType elementType(type, 0); - if (type.isSizedArray()) + if (type.isSizedArray() +#ifdef NV_EXTENSIONS + && !type.getQualifier().isPerView() +#endif + ) return type.getOuterArraySize() * computeTypeLocationSize(elementType, stage); - else + else { +#ifdef NV_EXTENSIONS + // unset perViewNV attributes for arrayed per-view outputs: "perviewNV vec4 v[MAX_VIEWS][3];" + elementType.getQualifier().perViewNV = false; +#endif return computeTypeLocationSize(elementType, stage); + } } // "The locations consumed by block and structure members are determined by applying the rules above diff --git a/glslang/MachineIndependent/localintermediate.h b/glslang/MachineIndependent/localintermediate.h index d5ee86eee..626a2baa4 100644 --- a/glslang/MachineIndependent/localintermediate.h +++ b/glslang/MachineIndependent/localintermediate.h @@ -237,6 +237,8 @@ public: layoutOverrideCoverage(false), geoPassthroughEXT(false), computeDerivativeMode(LayoutDerivativeNone), + primitives(TQualifier::layoutNotSet), + numTaskNVBlocks(0), #endif autoMapBindings(false), autoMapLocations(false), @@ -427,6 +429,10 @@ public: int getNumEntryPoints() const { return numEntryPoints; } int getNumErrors() const { return numErrors; } void addPushConstantCount() { ++numPushConstants; } +#ifdef NV_EXTENSIONS + void addTaskNVCount() { ++numTaskNVBlocks; } +#endif + bool isRecursive() const { return recursive; } TIntermSymbol* addSymbol(const TVariable&); @@ -636,6 +642,14 @@ public: bool getGeoPassthroughEXT() const { return geoPassthroughEXT; } void setLayoutDerivativeMode(ComputeDerivativeMode mode) { computeDerivativeMode = mode; } ComputeDerivativeMode getLayoutDerivativeModeNone() const { return computeDerivativeMode; } + bool setPrimitives(int m) + { + if (primitives != TQualifier::layoutNotSet) + return primitives == m; + primitives = m; + return true; + } + int getPrimitives() const { return primitives; } #endif const char* addSemanticName(const TString& name) @@ -740,6 +754,8 @@ protected: bool layoutOverrideCoverage; bool geoPassthroughEXT; ComputeDerivativeMode computeDerivativeMode; + int primitives; + int numTaskNVBlocks; #endif // Base shift values diff --git a/glslang/Public/ShaderLang.h b/glslang/Public/ShaderLang.h index 7fc2ca346..1f29ee29c 100755 --- a/glslang/Public/ShaderLang.h +++ b/glslang/Public/ShaderLang.h @@ -94,6 +94,10 @@ typedef enum { EShLangGeometry, EShLangFragment, EShLangCompute, +#ifdef NV_EXTENSIONS + EShLangTaskNV, + EShLangMeshNV, +#endif EShLangCount, } EShLanguage; // would be better as stage, but this is ancient now @@ -104,6 +108,10 @@ typedef enum { EShLangGeometryMask = (1 << EShLangGeometry), EShLangFragmentMask = (1 << EShLangFragment), EShLangComputeMask = (1 << EShLangCompute), +#ifdef NV_EXTENSIONS + EShLangTaskNVMask = (1 << EShLangTaskNV), + EShLangMeshNVMask = (1 << EShLangMeshNV), +#endif } EShLanguageMask; namespace glslang { diff --git a/gtests/Spv.FromFile.cpp b/gtests/Spv.FromFile.cpp index 854b073e7..151ad2bdb 100644 --- a/gtests/Spv.FromFile.cpp +++ b/gtests/Spv.FromFile.cpp @@ -506,6 +506,13 @@ INSTANTIATE_TEST_CASE_P( "spv.computeShaderDerivatives.comp", "spv.computeShaderDerivatives2.comp", "spv.shaderImageFootprint.frag", + "spv.meshShaderBuiltins.mesh", + "spv.meshShaderUserDefined.mesh", + "spv.meshShaderPerViewBuiltins.mesh", + "spv.meshShaderPerViewUserDefined.mesh", + "spv.meshShaderSharedMem.mesh", + "spv.meshShaderTaskMem.mesh", + "spv.meshTaskShader.task", })), FileNameAsCustomTestSuffix ); diff --git a/gtests/TestFixture.cpp b/gtests/TestFixture.cpp index 77bada5f7..c560e1fe5 100644 --- a/gtests/TestFixture.cpp +++ b/gtests/TestFixture.cpp @@ -60,6 +60,12 @@ EShLanguage GetShaderStage(const std::string& stage) return EShLangFragment; } else if (stage == "comp") { return EShLangCompute; +#ifdef NV_EXTENSIONS + } else if (stage == "task") { + return EShLangTaskNV; + } else if (stage == "mesh") { + return EShLangMeshNV; +#endif } else { assert(0 && "Unknown shader stage"); return EShLangCount;