From 06c2eee720a0d0b19c4c9026d962c15cc898ed5c Mon Sep 17 00:00:00 2001 From: Torosdagli Date: Thu, 19 Mar 2020 11:09:57 -0400 Subject: [PATCH] GL_EXT_ray_query updates --- SPIRV/GLSL.ext.KHR.h | 4 +- SPIRV/GlslangToSpv.cpp | 166 +- SPIRV/SpvBuilder.cpp | 16 + SPIRV/SpvBuilder.h | 3 + SPIRV/doc.cpp | 122 + SPIRV/spirv.hpp | 26 + glslang/Include/BaseTypes.h | 2 + glslang/Include/Types.h | 4 +- glslang/Include/intermediate.h | 30 + glslang/MachineIndependent/Initialize.cpp | 93 +- glslang/MachineIndependent/Intermediate.cpp | 2 + .../MachineIndependent/ParseContextBase.cpp | 4 + glslang/MachineIndependent/ParseHelper.cpp | 26 +- glslang/MachineIndependent/ParseHelper.h | 2 + glslang/MachineIndependent/Scan.cpp | 8 + glslang/MachineIndependent/SymbolTable.cpp | 2 + glslang/MachineIndependent/Versions.cpp | 3 + glslang/MachineIndependent/Versions.h | 2 + glslang/MachineIndependent/glslang.m4 | 6 + glslang/MachineIndependent/glslang.y | 7 + glslang/MachineIndependent/glslang_tab.cpp | 6590 +++++++++-------- glslang/MachineIndependent/glslang_tab.cpp.h | 525 +- glslang/MachineIndependent/intermOut.cpp | 25 + 23 files changed, 4114 insertions(+), 3554 deletions(-) diff --git a/SPIRV/GLSL.ext.KHR.h b/SPIRV/GLSL.ext.KHR.h index b8cf04ff..d783a8f2 100644 --- a/SPIRV/GLSL.ext.KHR.h +++ b/SPIRV/GLSL.ext.KHR.h @@ -1,5 +1,6 @@ /* -** Copyright (c) 2014-2016 The Khronos Group Inc. +** Copyright (c) 2014-2020 The Khronos Group Inc. +** Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. ** ** Permission is hereby granted, free of charge, to any person obtaining a copy ** of this software and/or associated documentation files (the "Materials"), @@ -46,4 +47,5 @@ static const char* const E_SPV_EXT_fragment_shader_interlock = "SPV_EXT_fragm static const char* const E_SPV_KHR_shader_clock = "SPV_KHR_shader_clock"; static const char* const E_SPV_KHR_non_semantic_info = "SPV_KHR_non_semantic_info"; static const char* const E_SPV_KHR_ray_tracing = "SPV_KHR_ray_tracing"; +static const char* const E_SPV_KHR_ray_query = "SPV_KHR_ray_query"; #endif // #ifndef GLSLextKHR_H diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp index 565f60d5..c3808c48 100644 --- a/SPIRV/GlslangToSpv.cpp +++ b/SPIRV/GlslangToSpv.cpp @@ -2,6 +2,7 @@ // Copyright (C) 2014-2016 LunarG, Inc. // Copyright (C) 2015-2020 Google, Inc. // Copyright (C) 2017 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -1181,6 +1182,8 @@ spv::LoopControlMask TGlslangToSpvTraverser::TranslateLoopControl(const glslang: // Translate glslang type to SPIR-V storage class. spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::TType& type) { + if (type.getBasicType() == glslang::EbtRayQuery) + return spv::StorageClassFunction; if (type.getQualifier().isPipeInput()) return spv::StorageClassInput; if (type.getQualifier().isPipeOutput()) @@ -2703,6 +2706,13 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt case glslang::EOpWritePackedPrimitiveIndices4x8NV: noReturnValue = true; break; + case glslang::EOpRayQueryInitialize: + case glslang::EOpRayQueryTerminate: + case glslang::EOpRayQueryGenerateIntersection: + case glslang::EOpRayQueryConfirmIntersection: + noReturnValue = true; + break; + case glslang::EOpCooperativeMatrixLoad: case glslang::EOpCooperativeMatrixStore: noReturnValue = true; @@ -2769,6 +2779,25 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt lvalue = true; break; + case glslang::EOpRayQueryInitialize: + case glslang::EOpRayQueryGenerateIntersection: + case glslang::EOpRayQueryGetIntersectionType: + case glslang::EOpRayQueryGetIntersectionT: + case glslang::EOpRayQueryGetIntersectionInstanceCustomIndex: + case glslang::EOpRayQueryGetIntersectionInstanceId: + case glslang::EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset: + case glslang::EOpRayQueryGetIntersectionGeometryIndex: + case glslang::EOpRayQueryGetIntersectionPrimitiveIndex: + case glslang::EOpRayQueryGetIntersectionBarycentrics: + case glslang::EOpRayQueryGetIntersectionFrontFace: + case glslang::EOpRayQueryGetIntersectionObjectRayDirection: + case glslang::EOpRayQueryGetIntersectionObjectRayOrigin: + case glslang::EOpRayQueryGetIntersectionObjectToWorld: + case glslang::EOpRayQueryGetIntersectionWorldToObject: + if (arg == 0) + lvalue = true; + break; + case glslang::EOpAtomicAdd: case glslang::EOpAtomicMin: case glslang::EOpAtomicMax: @@ -2913,7 +2942,29 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt lvalueCoherentFlags |= TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType()); } else { builder.setLine(node->getLoc().line, node->getLoc().getFilename()); - operands.push_back(accessChainLoad(glslangOperands[arg]->getAsTyped()->getType())); + glslang::TOperator glslangOp = node->getOp(); + if (arg == 1 && + (glslangOp == glslang::EOpRayQueryGetIntersectionType || + glslangOp == glslang::EOpRayQueryGetIntersectionT || + glslangOp == glslang::EOpRayQueryGetIntersectionInstanceCustomIndex || + glslangOp == glslang::EOpRayQueryGetIntersectionInstanceId || + glslangOp == glslang::EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset || + glslangOp == glslang::EOpRayQueryGetIntersectionGeometryIndex || + glslangOp == glslang::EOpRayQueryGetIntersectionPrimitiveIndex || + glslangOp == glslang::EOpRayQueryGetIntersectionBarycentrics || + glslangOp == glslang::EOpRayQueryGetIntersectionFrontFace || + glslangOp == glslang::EOpRayQueryGetIntersectionObjectRayDirection || + glslangOp == glslang::EOpRayQueryGetIntersectionObjectRayOrigin || + glslangOp == glslang::EOpRayQueryGetIntersectionObjectToWorld || + glslangOp == glslang::EOpRayQueryGetIntersectionWorldToObject + )) { + bool cond = glslangOperands[arg]->getAsConstantUnion()->getConstArray()[0].getBConst(); + operands.push_back(builder.makeIntConstant(cond ? 1 : 0)); + } + else { + operands.push_back(accessChainLoad(glslangOperands[arg]->getAsTyped()->getType())); + } + } } @@ -3549,6 +3600,9 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty case glslang::EbtAccStruct: spvType = builder.makeAccelerationStructureType(); break; + case glslang::EbtRayQuery: + spvType = builder.makeRayQueryType(); + break; case glslang::EbtReference: { // Make the forward pointer, then recurse to convert the structure type, then @@ -7615,6 +7669,103 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv:: return 0; } break; + case glslang::EOpRayQueryInitialize: { + builder.createNoResultOp(spv::OpRayQueryInitializeKHR, operands); + return 0; + } break; + case glslang::EOpRayQueryTerminate: { + builder.createNoResultOp(spv::OpRayQueryTerminateKHR, operands); + return 0; + } break; + case glslang::EOpRayQueryGenerateIntersection: { + builder.createNoResultOp(spv::OpRayQueryGenerateIntersectionKHR, operands); + return 0; + } break; + case glslang::EOpRayQueryConfirmIntersection: { + builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR, operands); + return 0; + } break; + case glslang::EOpRayQueryProceed: { + typeId = builder.makeBoolType(); + opCode = spv::OpRayQueryProceedKHR; + } + break; + case glslang::EOpRayQueryGetIntersectionType: { + typeId = builder.makeIntType(32); + opCode = spv::OpRayQueryGetIntersectionTypeKHR; + } break; + case glslang::EOpRayQueryGetRayTMin: { + typeId = builder.makeFloatType(32); + opCode = spv::OpRayQueryGetRayTMinKHR; + } break; + case glslang::EOpRayQueryGetRayFlags: { + typeId = builder.makeIntType(32); + opCode = spv::OpRayQueryGetRayFlagsKHR; + } break; + case glslang::EOpRayQueryGetIntersectionT: { + typeId = builder.makeIntType(32); + opCode = spv::OpRayQueryGetIntersectionTKHR; + } break; + case glslang::EOpRayQueryGetIntersectionInstanceCustomIndex: { + typeId = builder.makeIntType(32); + opCode = spv::OpRayQueryGetIntersectionInstanceCustomIndexKHR; + } break; + case glslang::EOpRayQueryGetIntersectionInstanceId: { + typeId = builder.makeIntType(32); + opCode = spv::OpRayQueryGetIntersectionInstanceIdKHR; + } break; + case glslang::EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset: { + typeId = builder.makeIntType(32); + opCode = spv::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR; + } break; + case glslang::EOpRayQueryGetIntersectionGeometryIndex: { + typeId = builder.makeIntType(32); + opCode = spv::OpRayQueryGetIntersectionGeometryIndexKHR; + } break; + case glslang::EOpRayQueryGetIntersectionPrimitiveIndex: { + typeId = builder.makeIntType(32); + opCode = spv::OpRayQueryGetIntersectionPrimitiveIndexKHR; + } break; + case glslang::EOpRayQueryGetIntersectionBarycentrics: { + typeId = builder.makeVectorType(builder.makeFloatType(32), 2); + opCode = spv::OpRayQueryGetIntersectionBarycentricsKHR; + } break; + case glslang::EOpRayQueryGetIntersectionFrontFace: { + typeId = builder.makeBoolType(); + opCode = spv::OpRayQueryGetIntersectionFrontFaceKHR; + } break; + case glslang::EOpRayQueryGetIntersectionCandidateAABBOpaque: { + typeId = builder.makeBoolType(); + opCode = spv::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR; + } break; + case glslang::EOpRayQueryGetIntersectionObjectRayDirection: { + typeId = builder.makeVectorType(builder.makeFloatType(32), 3); + opCode = spv::OpRayQueryGetIntersectionObjectRayDirectionKHR; + } break; + case glslang::EOpRayQueryGetIntersectionObjectRayOrigin: { + typeId = builder.makeVectorType(builder.makeFloatType(32), 3); + opCode = spv::OpRayQueryGetIntersectionObjectRayOriginKHR; + } break; + case glslang::EOpRayQueryGetWorldRayDirection: { + typeId = builder.makeVectorType(builder.makeFloatType(32), 3); + opCode = spv::OpRayQueryGetWorldRayDirectionKHR; + } break; + case glslang::EOpRayQueryGetWorldRayOrigin: { + typeId = builder.makeVectorType(builder.makeFloatType(32), 3); + opCode = spv::OpRayQueryGetWorldRayOriginKHR; + } break; + case glslang::EOpRayQueryGetIntersectionObjectToWorld: { + typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3); + // https://gitlab.khronos.org/spirv/spirv-extensions/blob/cdf44fd4b854a5297bf2191d4f57f9bccbc49098/SPV_KHR_ray_query.asciidoc#ray_query_candidate_intersection_type + // or per description is it typeId = builder.makeVectorType(builder.makeVectorType(builder.makeFloatType(32), 3), 4); + opCode = spv::OpRayQueryGetIntersectionObjectToWorldKHR; + } break; + case glslang::EOpRayQueryGetIntersectionWorldToObject: { + typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3); + // https://gitlab.khronos.org/spirv/spirv-extensions/blob/cdf44fd4b854a5297bf2191d4f57f9bccbc49098/SPV_KHR_ray_query.asciidoc#ray_query_candidate_intersection_type + // or per description is it typeId = builder.makeVectorType(builder.makeVectorType(builder.makeFloatType(32), 3), 4); + opCode = spv::OpRayQueryGetIntersectionWorldToObjectKHR; + } break; case glslang::EOpWritePackedPrimitiveIndices4x8NV: builder.createNoResultOp(spv::OpWritePackedPrimitiveIndices4x8NV, operands); return 0; @@ -7817,7 +7968,18 @@ spv::Id TGlslangToSpvTraverser::createNoArgOperation(glslang::TOperator op, spv: case glslang::EOpTerminateRay: builder.createNoResultOp(spv::OpTerminateRayKHR); return 0; - + case glslang::EOpRayQueryInitialize: + builder.createNoResultOp(spv::OpRayQueryInitializeKHR); + return 0; + case glslang::EOpRayQueryTerminate: + builder.createNoResultOp(spv::OpRayQueryTerminateKHR); + return 0; + case glslang::EOpRayQueryGenerateIntersection: + builder.createNoResultOp(spv::OpRayQueryGenerateIntersectionKHR); + return 0; + case glslang::EOpRayQueryConfirmIntersection: + builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR); + return 0; case glslang::EOpBeginInvocationInterlock: builder.createNoResultOp(spv::OpBeginInvocationInterlockEXT); return 0; diff --git a/SPIRV/SpvBuilder.cpp b/SPIRV/SpvBuilder.cpp index 075cc985..6cf70a12 100644 --- a/SPIRV/SpvBuilder.cpp +++ b/SPIRV/SpvBuilder.cpp @@ -1,6 +1,7 @@ // // Copyright (C) 2014-2015 LunarG, Inc. // Copyright (C) 2015-2018 Google, Inc. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -616,6 +617,21 @@ Id Builder::makeAccelerationStructureType() return type->getResultId(); } + +Id Builder::makeRayQueryType() +{ + Instruction *type; + if (groupedTypes[OpTypeRayQueryProvisionalKHR].size() == 0) { + type = new Instruction(getUniqueId(), NoType, OpTypeRayQueryProvisionalKHR); + groupedTypes[OpTypeRayQueryProvisionalKHR].push_back(type); + constantsTypesGlobals.push_back(std::unique_ptr(type)); + module.mapInstruction(type); + } else { + type = groupedTypes[OpTypeRayQueryProvisionalKHR].back(); + } + + return type->getResultId(); +} #endif Id Builder::getDerefTypeId(Id resultId) const diff --git a/SPIRV/SpvBuilder.h b/SPIRV/SpvBuilder.h index 88590297..71b90d60 100644 --- a/SPIRV/SpvBuilder.h +++ b/SPIRV/SpvBuilder.h @@ -2,6 +2,7 @@ // Copyright (C) 2014-2015 LunarG, Inc. // Copyright (C) 2015-2020 Google, Inc. // Copyright (C) 2017 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -183,6 +184,8 @@ public: // accelerationStructureNV type Id makeAccelerationStructureType(); + // rayQueryEXT type + Id makeRayQueryType(); // For querying about types. Id getTypeId(Id resultId) const { return module.getTypeId(resultId); } diff --git a/SPIRV/doc.cpp b/SPIRV/doc.cpp index f3c39992..b1f2b820 100644 --- a/SPIRV/doc.cpp +++ b/SPIRV/doc.cpp @@ -1,5 +1,6 @@ // // Copyright (C) 2014-2015 LunarG, Inc. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -892,6 +893,8 @@ const char* CapabilityString(int info) case CapabilityGroupNonUniformPartitionedNV: return "GroupNonUniformPartitionedNV"; case CapabilityRayTracingNV: return "RayTracingNV"; case CapabilityRayTracingProvisionalKHR: return "RayTracingProvisionalKHR"; + case CapabilityRayQueryProvisionalKHR: return "RayQueryProvisionalKHR"; + case CapabilityRayTraversalPrimitiveCullingProvisionalKHR: return "RayTraversalPrimitiveCullingProvisionalKHR"; case CapabilityComputeDerivativeGroupQuadsNV: return "ComputeDerivativeGroupQuadsNV"; case CapabilityComputeDerivativeGroupLinearNV: return "ComputeDerivativeGroupLinearNV"; case CapabilityFragmentBarycentricNV: return "FragmentBarycentricNV"; @@ -1337,6 +1340,31 @@ const char* OpcodeString(int op) case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV"; case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV"; + case OpTypeRayQueryProvisionalKHR: return "OpTypeRayQueryProvisionalKHR"; + case OpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR"; + case OpRayQueryTerminateKHR: return "OpRayQueryTerminateKHR"; + case OpRayQueryGenerateIntersectionKHR: return "OpRayQueryGenerateIntersectionKHR"; + case OpRayQueryConfirmIntersectionKHR: return "OpRayQueryConfirmIntersectionKHR"; + case OpRayQueryProceedKHR: return "OpRayQueryProceedKHR"; + case OpRayQueryGetIntersectionTypeKHR: return "OpRayQueryGetIntersectionTypeKHR"; + case OpRayQueryGetRayTMinKHR: return "OpRayQueryGetRayTMinKHR"; + case OpRayQueryGetRayFlagsKHR: return "OpRayQueryGetRayFlagsKHR"; + case OpRayQueryGetIntersectionTKHR: return "OpRayQueryGetIntersectionTKHR"; + case OpRayQueryGetIntersectionInstanceCustomIndexKHR: return "OpRayQueryGetIntersectionInstanceCustomIndexKHR"; + case OpRayQueryGetIntersectionInstanceIdKHR: return "OpRayQueryGetIntersectionInstanceIdKHR"; + case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR"; + case OpRayQueryGetIntersectionGeometryIndexKHR: return "OpRayQueryGetIntersectionGeometryIndexKHR"; + case OpRayQueryGetIntersectionPrimitiveIndexKHR: return "OpRayQueryGetIntersectionPrimitiveIndexKHR"; + case OpRayQueryGetIntersectionBarycentricsKHR: return "OpRayQueryGetIntersectionBarycentricsKHR"; + case OpRayQueryGetIntersectionFrontFaceKHR: return "OpRayQueryGetIntersectionFrontFaceKHR"; + case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR"; + case OpRayQueryGetIntersectionObjectRayDirectionKHR: return "OpRayQueryGetIntersectionObjectRayDirectionKHR"; + case OpRayQueryGetIntersectionObjectRayOriginKHR: return "OpRayQueryGetIntersectionObjectRayOriginKHR"; + case OpRayQueryGetWorldRayDirectionKHR: return "OpRayQueryGetWorldRayDirectionKHR"; + case OpRayQueryGetWorldRayOriginKHR: return "OpRayQueryGetWorldRayOriginKHR"; + case OpRayQueryGetIntersectionObjectToWorldKHR: return "OpRayQueryGetIntersectionObjectToWorldKHR"; + case OpRayQueryGetIntersectionWorldToObjectKHR: return "OpRayQueryGetIntersectionWorldToObjectKHR"; + case OpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV"; case OpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV"; case OpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV"; @@ -2722,6 +2750,100 @@ void Parameterize() InstructionDesc[OpExecuteCallableKHR].operands.push(OperandId, "CallableData ID"); InstructionDesc[OpExecuteCallableKHR].setResultAndType(false, false); + // Ray Query + InstructionDesc[OpTypeAccelerationStructureKHR].setResultAndType(true, false); + InstructionDesc[OpTypeRayQueryProvisionalKHR].setResultAndType(true, false); + + InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'AccelerationS'"); + InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayFlags'"); + InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'CullMask'"); + InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Origin'"); + InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmin'"); + InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Direction'"); + InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmax'"); + InstructionDesc[OpRayQueryInitializeKHR].setResultAndType(false, false); + + InstructionDesc[OpRayQueryTerminateKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryTerminateKHR].setResultAndType(false, false); + + InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'THit'"); + InstructionDesc[OpRayQueryGenerateIntersectionKHR].setResultAndType(false, false); + + InstructionDesc[OpRayQueryConfirmIntersectionKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryConfirmIntersectionKHR].setResultAndType(false, false); + + InstructionDesc[OpRayQueryProceedKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryProceedKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'Committed'"); + InstructionDesc[OpRayQueryGetIntersectionTypeKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetRayTMinKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetRayTMinKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetRayFlagsKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetRayFlagsKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'Committed'"); + InstructionDesc[OpRayQueryGetIntersectionTKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'Committed'"); + InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'Committed'"); + InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'Committed'"); + InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'Committed'"); + InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'Committed'"); + InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'Committed'"); + InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'Committed'"); + InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'Committed'"); + InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'Committed'"); + InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetWorldRayOriginKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetWorldRayOriginKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'Committed'"); + InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].setResultAndType(true, true); + + InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'RayQuery'"); + InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'Committed'"); + InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].setResultAndType(true, true); + InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Sampled Image'"); InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coordinate'"); InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Granularity'"); diff --git a/SPIRV/spirv.hpp b/SPIRV/spirv.hpp index 9f98683d..c2f79090 100644 --- a/SPIRV/spirv.hpp +++ b/SPIRV/spirv.hpp @@ -1,4 +1,5 @@ // Copyright (c) 2014-2020 The Khronos Group Inc. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and/or associated documentation files (the "Materials"), @@ -1939,6 +1940,31 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break; case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break; case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; + case OpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break; + case OpTypeRayQueryProvisionalKHR: *hasResult = true; *hasResultType = false; break; + case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break; case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; case OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break; diff --git a/glslang/Include/BaseTypes.h b/glslang/Include/BaseTypes.h index b2d6cb80..816b1794 100644 --- a/glslang/Include/BaseTypes.h +++ b/glslang/Include/BaseTypes.h @@ -2,6 +2,7 @@ // Copyright (C) 2002-2005 3Dlabs Inc. Ltd. // Copyright (C) 2012-2013 LunarG, Inc. // Copyright (C) 2017 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -63,6 +64,7 @@ enum TBasicType { EbtBlock, EbtAccStruct, EbtReference, + EbtRayQuery, // HLSL types that live only temporarily. EbtString, diff --git a/glslang/Include/Types.h b/glslang/Include/Types.h index 350b0e89..a8c57a4a 100644 --- a/glslang/Include/Types.h +++ b/glslang/Include/Types.h @@ -3,6 +3,7 @@ // Copyright (C) 2012-2016 LunarG, Inc. // Copyright (C) 2015-2016 Google, Inc. // Copyright (C) 2017 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -1673,7 +1674,7 @@ public: } virtual bool isOpaque() const { return basicType == EbtSampler #ifndef GLSLANG_WEB - || basicType == EbtAtomicUint || basicType == EbtAccStruct + || basicType == EbtAtomicUint || basicType == EbtAccStruct || basicType == EbtRayQuery #endif ; } virtual bool isBuiltIn() const { return getQualifier().builtIn != EbvNone; } @@ -1950,6 +1951,7 @@ public: case EbtStruct: return "structure"; case EbtBlock: return "block"; case EbtAccStruct: return "accelerationStructureNV"; + case EbtRayQuery: return "rayQueryEXT"; case EbtReference: return "reference"; #endif default: return "unknown type"; diff --git a/glslang/Include/intermediate.h b/glslang/Include/intermediate.h index 47cc274a..bf12fcf8 100644 --- a/glslang/Include/intermediate.h +++ b/glslang/Include/intermediate.h @@ -2,6 +2,7 @@ // Copyright (C) 2002-2005 3Dlabs Inc. Ltd. // Copyright (C) 2012-2016 LunarG, Inc. // Copyright (C) 2017 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -916,6 +917,35 @@ enum TOperator { EOpTerminateRay, EOpExecuteCallable, EOpWritePackedPrimitiveIndices4x8NV, + + // + // GL_EXT_ray_query operations + // + + EOpRayQueryInitialize, + EOpRayQueryTerminate, + EOpRayQueryGenerateIntersection, + EOpRayQueryConfirmIntersection, + EOpRayQueryProceed, + EOpRayQueryGetIntersectionType, + EOpRayQueryGetRayTMin, + EOpRayQueryGetRayFlags, + EOpRayQueryGetIntersectionT, + EOpRayQueryGetIntersectionInstanceCustomIndex, + EOpRayQueryGetIntersectionInstanceId, + EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset, + EOpRayQueryGetIntersectionGeometryIndex, + EOpRayQueryGetIntersectionPrimitiveIndex, + EOpRayQueryGetIntersectionBarycentrics, + EOpRayQueryGetIntersectionFrontFace, + EOpRayQueryGetIntersectionCandidateAABBOpaque, + EOpRayQueryGetIntersectionObjectRayDirection, + EOpRayQueryGetIntersectionObjectRayOrigin, + EOpRayQueryGetWorldRayDirection, + EOpRayQueryGetWorldRayOrigin, + EOpRayQueryGetIntersectionObjectToWorld, + EOpRayQueryGetIntersectionWorldToObject, + // // HLSL operations // diff --git a/glslang/MachineIndependent/Initialize.cpp b/glslang/MachineIndependent/Initialize.cpp index 92326a96..0f31225a 100644 --- a/glslang/MachineIndependent/Initialize.cpp +++ b/glslang/MachineIndependent/Initialize.cpp @@ -3,6 +3,7 @@ // Copyright (C) 2012-2016 LunarG, Inc. // Copyright (C) 2015-2020 Google, Inc. // Copyright (C) 2017 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -4322,8 +4323,33 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV "\n"); } - // Builtins for GL_NV_ray_tracing/GL_EXT_ray_tracing + // Builtins for GL_NV_ray_tracing/GL_EXT_ray_tracing//GL_EXT_ray_query if (profile != EEsProfile && version >= 460) { + commonBuiltins.append("void rayQueryInitializeEXT(rayQueryEXT, accelerationStructureEXT, uint, uint, vec3, float, vec3, float);" + "bool rayQueryProceedEXT(rayQueryEXT);" + "void rayQueryTerminateEXT(rayQueryEXT);" + "void rayQueryGenerateIntersectionEXT(rayQueryEXT, float);" + "void rayQueryConfirmIntersectionEXT(rayQueryEXT);" + "uint rayQueryGetIntersectionTypeEXT(rayQueryEXT, bool);" + "float rayQueryGetRayTMinEXT(rayQueryEXT);" + "uint rayQueryGetRayFlagsEXT(rayQueryEXT);" + "vec3 rayQueryGetWorldRayOriginEXT(rayQueryEXT);" + "vec3 rayQueryGetWorldRayDirectionEXT(rayQueryEXT);" + "float rayQueryGetIntersectionTEXT(rayQueryEXT, bool);" + "int rayQueryGetIntersectionInstanceCustomIndexEXT(rayQueryEXT, bool);" + "int rayQueryGetIntersectionInstanceIdEXT(rayQueryEXT, bool);" + "uint rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT(rayQueryEXT, bool);" + "int rayQueryGetIntersectionGeometryIndexEXT(rayQueryEXT, bool);" + "int rayQueryGetIntersectionPrimitiveIndexEXT(rayQueryEXT, bool);" + "vec2 rayQueryGetIntersectionBarycentricsEXT(rayQueryEXT, bool);" + "bool rayQueryGetIntersectionFrontFaceEXT(rayQueryEXT, bool);" + "bool rayQueryGetIntersectionCandidateAABBOpaqueEXT(rayQueryEXT);" + "vec3 rayQueryGetIntersectionObjectRayDirectionEXT(rayQueryEXT, bool);" + "vec3 rayQueryGetIntersectionObjectRayOriginEXT(rayQueryEXT, bool);" + "mat4x3 rayQueryGetIntersectionObjectToWorldEXT(rayQueryEXT, bool);" + "mat4x3 rayQueryGetIntersectionWorldToObjectEXT(rayQueryEXT, bool);" + "\n"); + stageBuiltins[EShLangRayGen].append( "void traceNV(accelerationStructureNV,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);" "void traceRayEXT(accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);" @@ -5436,6 +5462,17 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV "const uint gl_HitKindFrontFacingTriangleEXT = 254U;" "const uint gl_HitKindBackFacingTriangleEXT = 255U;" "\n"; + + const char *constRayQueryIntersection = + "const uint gl_RayQueryCandidateIntersectionEXT = 0U;" + "const uint gl_RayQueryCommittedIntersectionEXT = 1U;" + "const uint gl_RayQueryCommittedIntersectionNoneEXT = 0U;" + "const uint gl_RayQueryCommittedIntersectionTriangleEXT = 1U;" + "const uint gl_RayQueryCommittedIntersectionGeneratedEXT = 2U;" + "const uint gl_RayQueryCandidateIntersectionTriangleEXT = 0U;" + "const uint gl_RayQueryCandidateIntersectionAABBEXT = 1U;" + "\n"; + const char *rayGenDecls = "in uvec3 gl_LaunchIDNV;" "in uvec3 gl_LaunchIDEXT;" @@ -5535,6 +5572,7 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV "\n"; + commonBuiltins.append(constRayQueryIntersection); stageBuiltins[EShLangRayGen].append(rayGenDecls); stageBuiltins[EShLangRayGen].append(constRayFlags); @@ -7522,6 +7560,32 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion BuiltInVariable("gl_FragStencilRefARB", EbvFragStencilRef, symbolTable); } + if (profile != EEsProfile && version >= 460) { + symbolTable.setFunctionExtensions("rayQueryInitializeEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryTerminateEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGenerateIntersectionEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryConfirmIntersectionEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryProceedEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionTypeEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionTEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetRayFlagsEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetRayTMinEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionInstanceCustomIndexEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionInstanceIdEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionGeometryIndexEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionPrimitiveIndexEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionBarycentricsEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionFrontFaceEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionCandidateAABBOpaqueEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionObjectRayDirectionEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionObjectRayOriginEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionObjectToWorldEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetIntersectionWorldToObjectEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetWorldRayOriginEXT", 1, &E_GL_EXT_ray_query); + symbolTable.setFunctionExtensions("rayQueryGetWorldRayDirectionEXT", 1, &E_GL_EXT_ray_query); + } + if ((profile != EEsProfile && version >= 130) || (profile == EEsProfile && version >= 310)) { BuiltInVariable("gl_SampleID", EbvSampleId, symbolTable); @@ -8860,6 +8924,33 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.relateToOperator("dFdyCoarse", EOpDPdyCoarse); symbolTable.relateToOperator("fwidthCoarse", EOpFwidthCoarse); } + + if (profile != EEsProfile && version >= 460) { + symbolTable.relateToOperator("rayQueryInitializeEXT", EOpRayQueryInitialize); + symbolTable.relateToOperator("rayQueryTerminateEXT", EOpRayQueryTerminate); + symbolTable.relateToOperator("rayQueryGenerateIntersectionEXT", EOpRayQueryGenerateIntersection); + symbolTable.relateToOperator("rayQueryConfirmIntersectionEXT", EOpRayQueryConfirmIntersection); + symbolTable.relateToOperator("rayQueryProceedEXT", EOpRayQueryProceed); + symbolTable.relateToOperator("rayQueryGetIntersectionTypeEXT", EOpRayQueryGetIntersectionType); + symbolTable.relateToOperator("rayQueryGetRayTMinEXT", EOpRayQueryGetRayTMin); + symbolTable.relateToOperator("rayQueryGetRayFlagsEXT", EOpRayQueryGetRayFlags); + symbolTable.relateToOperator("rayQueryGetIntersectionTEXT", EOpRayQueryGetIntersectionT); + symbolTable.relateToOperator("rayQueryGetIntersectionInstanceCustomIndexEXT", EOpRayQueryGetIntersectionInstanceCustomIndex); + symbolTable.relateToOperator("rayQueryGetIntersectionInstanceIdEXT", EOpRayQueryGetIntersectionInstanceId); + symbolTable.relateToOperator("rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT", EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset); + symbolTable.relateToOperator("rayQueryGetIntersectionGeometryIndexEXT", EOpRayQueryGetIntersectionGeometryIndex); + symbolTable.relateToOperator("rayQueryGetIntersectionPrimitiveIndexEXT", EOpRayQueryGetIntersectionPrimitiveIndex); + symbolTable.relateToOperator("rayQueryGetIntersectionBarycentricsEXT", EOpRayQueryGetIntersectionBarycentrics); + symbolTable.relateToOperator("rayQueryGetIntersectionFrontFaceEXT", EOpRayQueryGetIntersectionFrontFace); + symbolTable.relateToOperator("rayQueryGetIntersectionCandidateAABBOpaqueEXT", EOpRayQueryGetIntersectionCandidateAABBOpaque); + symbolTable.relateToOperator("rayQueryGetIntersectionObjectRayDirectionEXT", EOpRayQueryGetIntersectionObjectRayDirection); + symbolTable.relateToOperator("rayQueryGetIntersectionObjectRayOriginEXT", EOpRayQueryGetIntersectionObjectRayOrigin); + symbolTable.relateToOperator("rayQueryGetWorldRayDirectionEXT", EOpRayQueryGetWorldRayDirection); + symbolTable.relateToOperator("rayQueryGetWorldRayOriginEXT", EOpRayQueryGetWorldRayOrigin); + symbolTable.relateToOperator("rayQueryGetIntersectionObjectToWorldEXT", EOpRayQueryGetIntersectionObjectToWorld); + symbolTable.relateToOperator("rayQueryGetIntersectionWorldToObjectEXT", EOpRayQueryGetIntersectionWorldToObject); + } + symbolTable.relateToOperator("interpolateAtCentroid", EOpInterpolateAtCentroid); symbolTable.relateToOperator("interpolateAtSample", EOpInterpolateAtSample); symbolTable.relateToOperator("interpolateAtOffset", EOpInterpolateAtOffset); diff --git a/glslang/MachineIndependent/Intermediate.cpp b/glslang/MachineIndependent/Intermediate.cpp index f6a5e7f2..5bd764ef 100755 --- a/glslang/MachineIndependent/Intermediate.cpp +++ b/glslang/MachineIndependent/Intermediate.cpp @@ -3,6 +3,7 @@ // Copyright (C) 2012-2015 LunarG, Inc. // Copyright (C) 2015-2020 Google, Inc. // Copyright (C) 2017 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -539,6 +540,7 @@ bool TIntermediate::isConversionAllowed(TOperator op, TIntermTyped* node) const case EbtAtomicUint: case EbtSampler: case EbtAccStruct: + case EbtRayQuery: // opaque types can be passed to functions if (op == EOpFunction) break; diff --git a/glslang/MachineIndependent/ParseContextBase.cpp b/glslang/MachineIndependent/ParseContextBase.cpp index 81842d83..58da56da 100644 --- a/glslang/MachineIndependent/ParseContextBase.cpp +++ b/glslang/MachineIndependent/ParseContextBase.cpp @@ -1,6 +1,7 @@ // // Copyright (C) 2002-2005 3Dlabs Inc. Ltd. // Copyright (C) 2016 Google, Inc. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -184,6 +185,9 @@ bool TParseContextBase::lValueErrorCheck(const TSourceLoc& loc, const char* op, case EbtAccStruct: message = "can't modify accelerationStructureNV"; break; + case EbtRayQuery: + message = "can't modify rayQueryEXT"; + break; #endif default: break; diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp index d338a7dd..01ef0942 100644 --- a/glslang/MachineIndependent/ParseHelper.cpp +++ b/glslang/MachineIndependent/ParseHelper.cpp @@ -3,6 +3,7 @@ // Copyright (C) 2012-2015 LunarG, Inc. // Copyright (C) 2015-2018 Google, Inc. // Copyright (C) 2017, 2019 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -2041,6 +2042,23 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan error(loc, "argument must be compile-time constant", "callable data number", ""); break; + case EOpRayQueryGetIntersectionType: + case EOpRayQueryGetIntersectionT: + case EOpRayQueryGetIntersectionInstanceCustomIndex: + case EOpRayQueryGetIntersectionInstanceId: + case EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset: + case EOpRayQueryGetIntersectionGeometryIndex: + case EOpRayQueryGetIntersectionPrimitiveIndex: + case EOpRayQueryGetIntersectionBarycentrics: + case EOpRayQueryGetIntersectionFrontFace: + case EOpRayQueryGetIntersectionObjectRayDirection: + case EOpRayQueryGetIntersectionObjectRayOrigin: + case EOpRayQueryGetIntersectionObjectToWorld: + case EOpRayQueryGetIntersectionWorldToObject: + if (!(*argp)[1]->getAsConstantUnion()) + error(loc, "argument must be compile-time constant", "committed", ""); + break; + case EOpTextureQuerySamples: case EOpImageQuerySamples: // GL_ARB_shader_texture_image_samples @@ -3241,6 +3259,11 @@ void TParseContext::accStructCheck(const TSourceLoc& loc, const TType& type, con } +void TParseContext::rayQueryCheck(const TSourceLoc& loc, const TType& type, const TString& identifier) +{ + return; +} + #endif // GLSLANG_WEB void TParseContext::transparentOpaqueCheck(const TSourceLoc& loc, const TType& type, const TString& identifier) @@ -3992,7 +4015,7 @@ void TParseContext::checkRuntimeSizable(const TSourceLoc& loc, const TIntermType } // check for additional things allowed by GL_EXT_nonuniform_qualifier - if (base.getBasicType() == EbtSampler || base.getBasicType() == EbtAccStruct || + if (base.getBasicType() == EbtSampler || base.getBasicType() == EbtAccStruct || base.getBasicType() == EbtRayQuery || (base.getBasicType() == EbtBlock && base.getType().getQualifier().isUniformOrBuffer())) requireExtensions(loc, 1, &E_GL_EXT_nonuniform_qualifier, "variable index"); else @@ -6488,6 +6511,7 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden #ifndef GLSLANG_WEB atomicUintCheck(loc, type, identifier); accStructCheck(loc, type, identifier); + rayQueryCheck(loc, type, identifier); checkAndResizeMeshViewDim(loc, type, /*isBlockMember*/ false); #endif if (type.getQualifier().storage == EvqConst && type.containsReference()) { diff --git a/glslang/MachineIndependent/ParseHelper.h b/glslang/MachineIndependent/ParseHelper.h index 20df6405..aea1eb60 100644 --- a/glslang/MachineIndependent/ParseHelper.h +++ b/glslang/MachineIndependent/ParseHelper.h @@ -2,6 +2,7 @@ // Copyright (C) 2002-2005 3Dlabs Inc. Ltd. // Copyright (C) 2012-2013 LunarG, Inc. // Copyright (C) 2015-2018 Google, Inc. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -359,6 +360,7 @@ public: void samplerCheck(const TSourceLoc&, const TType&, const TString& identifier, TIntermTyped* initializer); void atomicUintCheck(const TSourceLoc&, const TType&, const TString& identifier); void accStructCheck(const TSourceLoc & loc, const TType & type, const TString & identifier); + void rayQueryCheck(const TSourceLoc & loc, const TType & type, const TString & identifier); void transparentOpaqueCheck(const TSourceLoc&, const TType&, const TString& identifier); void memberQualifierCheck(glslang::TPublicType&); void globalQualifierFixCheck(const TSourceLoc&, TQualifier&); diff --git a/glslang/MachineIndependent/Scan.cpp b/glslang/MachineIndependent/Scan.cpp index 0fafe931..b37e1ef9 100644 --- a/glslang/MachineIndependent/Scan.cpp +++ b/glslang/MachineIndependent/Scan.cpp @@ -3,6 +3,7 @@ // Copyright (C) 2013 LunarG, Inc. // Copyright (C) 2017 ARM Limited. // Copyright (C) 2020 Google, Inc. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -715,6 +716,7 @@ void TScanContext::fillInKeywordMap() (*KeywordMap)["callableDataInEXT"] = CALLDATAINEXT; (*KeywordMap)["accelerationStructureNV"] = ACCSTRUCTNV; (*KeywordMap)["accelerationStructureEXT"] = ACCSTRUCTEXT; + (*KeywordMap)["rayQueryEXT"] = RAYQUERYEXT; (*KeywordMap)["perprimitiveNV"] = PERPRIMITIVENV; (*KeywordMap)["perviewNV"] = PERVIEWNV; (*KeywordMap)["taskNV"] = PERTASKNV; @@ -1031,6 +1033,12 @@ int TScanContext::tokenizeIdentifier() parseContext.extensionTurnedOn(E_GL_EXT_ray_tracing)) return keyword; return identifierOrType(); + case RAYQUERYEXT: + if (parseContext.symbolTable.atBuiltInLevel() || + (!parseContext.isEsProfile() && parseContext.version >= 460 + && parseContext.extensionTurnedOn(E_GL_EXT_ray_query))) + return keyword; + return identifierOrType(); case ATOMIC_UINT: if ((parseContext.isEsProfile() && parseContext.version >= 310) || parseContext.extensionTurnedOn(E_GL_ARB_shader_atomic_counters)) diff --git a/glslang/MachineIndependent/SymbolTable.cpp b/glslang/MachineIndependent/SymbolTable.cpp index 07c8b42f..5dc83539 100644 --- a/glslang/MachineIndependent/SymbolTable.cpp +++ b/glslang/MachineIndependent/SymbolTable.cpp @@ -3,6 +3,7 @@ // Copyright (C) 2012-2013 LunarG, Inc. // Copyright (C) 2017 ARM Limited. // Copyright (C) 2015-2018 Google, Inc. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -75,6 +76,7 @@ void TType::buildMangledName(TString& mangledName) const case EbtUint64: mangledName += "u64"; break; case EbtAtomicUint: mangledName += "au"; break; case EbtAccStruct: mangledName += "as"; break; + case EbtRayQuery: mangledName += "rq"; break; #endif case EbtSampler: switch (sampler.type) { diff --git a/glslang/MachineIndependent/Versions.cpp b/glslang/MachineIndependent/Versions.cpp index 819bac7c..180f5b3d 100644 --- a/glslang/MachineIndependent/Versions.cpp +++ b/glslang/MachineIndependent/Versions.cpp @@ -3,6 +3,7 @@ // Copyright (C) 2012-2013 LunarG, Inc. // Copyright (C) 2017 ARM Limited. // Copyright (C) 2015-2020 Google, Inc. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -296,6 +297,7 @@ void TParseVersions::initializeExtensionBehavior() extensionBehavior[E_GL_EXT_multiview] = EBhDisable; extensionBehavior[E_GL_EXT_shader_realtime_clock] = EBhDisable; extensionBehavior[E_GL_EXT_ray_tracing] = EBhDisable; + extensionBehavior[E_GL_EXT_ray_query] = EBhDisable; // OVR extensions extensionBehavior[E_GL_OVR_multiview] = EBhDisable; @@ -435,6 +437,7 @@ void TParseVersions::getPreamble(std::string& preamble) "#define E_GL_EXT_shader_atomic_int64 1\n" "#define E_GL_EXT_shader_realtime_clock 1\n" "#define E_GL_EXT_ray_tracing 1\n" + "#define E_GL_EXT_ray_query 1\n" "#define GL_AMD_shader_ballot 1\n" "#define GL_AMD_shader_trinary_minmax 1\n" diff --git a/glslang/MachineIndependent/Versions.h b/glslang/MachineIndependent/Versions.h index 173995fa..e8cebebf 100644 --- a/glslang/MachineIndependent/Versions.h +++ b/glslang/MachineIndependent/Versions.h @@ -3,6 +3,7 @@ // Copyright (C) 2012-2013 LunarG, Inc. // Copyright (C) 2017 ARM Limited. // Copyright (C) 2015-2018 Google, Inc. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -187,6 +188,7 @@ const char* const E_GL_EXT_demote_to_helper_invocation = "GL_EXT_demote_to_ const char* const E_GL_EXT_shader_realtime_clock = "GL_EXT_shader_realtime_clock"; const char* const E_GL_EXT_debug_printf = "GL_EXT_debug_printf"; const char* const E_GL_EXT_ray_tracing = "GL_EXT_ray_tracing"; +const char* const E_GL_EXT_ray_query = "GL_EXT_ray_query"; // Arrays of extensions for the above viewportEXTs duplications diff --git a/glslang/MachineIndependent/glslang.m4 b/glslang/MachineIndependent/glslang.m4 index 38b7608f..1432bf6e 100644 --- a/glslang/MachineIndependent/glslang.m4 +++ b/glslang/MachineIndependent/glslang.m4 @@ -3,6 +3,7 @@ // Copyright (C) 2012-2013 LunarG, Inc. // Copyright (C) 2017 ARM Limited. // Copyright (C) 2015-2019 Google, Inc. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -205,6 +206,7 @@ GLSLANG_WEB_EXCLUDE_ON %token ATOMIC_UINT %token ACCSTRUCTNV %token ACCSTRUCTEXT +%token RAYQUERYEXT %token FCOOPMATNV ICOOPMATNV UCOOPMATNV // combined image/sampler @@ -2406,6 +2408,10 @@ GLSLANG_WEB_EXCLUDE_ON $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); $$.basicType = EbtAccStruct; } + | RAYQUERYEXT { + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtRayQuery; + } | ATOMIC_UINT { parseContext.vulkanRemoved($1.loc, "atomic counter types"); $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); diff --git a/glslang/MachineIndependent/glslang.y b/glslang/MachineIndependent/glslang.y index c03847b9..e33d7d1c 100644 --- a/glslang/MachineIndependent/glslang.y +++ b/glslang/MachineIndependent/glslang.y @@ -3,6 +3,7 @@ // Copyright (C) 2012-2013 LunarG, Inc. // Copyright (C) 2017 ARM Limited. // Copyright (C) 2015-2019 Google, Inc. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -205,6 +206,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %token ATOMIC_UINT %token ACCSTRUCTNV %token ACCSTRUCTEXT +%token RAYQUERYEXT %token FCOOPMATNV ICOOPMATNV UCOOPMATNV // combined image/sampler @@ -2406,6 +2408,10 @@ type_specifier_nonarray $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); $$.basicType = EbtAccStruct; } + | RAYQUERYEXT { + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtRayQuery; + } | ATOMIC_UINT { parseContext.vulkanRemoved($1.loc, "atomic counter types"); $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); @@ -3879,3 +3885,4 @@ single_attribute %% + diff --git a/glslang/MachineIndependent/glslang_tab.cpp b/glslang/MachineIndependent/glslang_tab.cpp index ee9a654b..69f7f8e0 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp +++ b/glslang/MachineIndependent/glslang_tab.cpp @@ -62,7 +62,7 @@ /* Copy the first part of user declarations. */ -#line 68 "MachineIndependent/glslang.y" /* yacc.c:339 */ +#line 69 "glslang.y" /* yacc.c:339 */ /* Based on: @@ -88,7 +88,7 @@ Jutta Degener, 1995 using namespace glslang; -#line 92 "MachineIndependent/glslang_tab.cpp" /* yacc.c:339 */ +#line 92 "glslang_tab.cpp" /* yacc.c:339 */ # ifndef YY_NULLPTR # if defined __cplusplus && 201103L <= __cplusplus @@ -108,8 +108,8 @@ using namespace glslang; /* In a future release of Bison, this section will be replaced by #include "glslang_tab.cpp.h". */ -#ifndef YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED -# define YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED +#ifndef YY_YY_GLSLANG_TAB_CPP_H_INCLUDED +# define YY_YY_GLSLANG_TAB_CPP_H_INCLUDED /* Debug traces. */ #ifndef YYDEBUG # define YYDEBUG 1 @@ -282,263 +282,264 @@ extern int yydebug; ATOMIC_UINT = 414, ACCSTRUCTNV = 415, ACCSTRUCTEXT = 416, - FCOOPMATNV = 417, - ICOOPMATNV = 418, - UCOOPMATNV = 419, - SAMPLERCUBEARRAY = 420, - SAMPLERCUBEARRAYSHADOW = 421, - ISAMPLERCUBEARRAY = 422, - USAMPLERCUBEARRAY = 423, - SAMPLER1D = 424, - SAMPLER1DARRAY = 425, - SAMPLER1DARRAYSHADOW = 426, - ISAMPLER1D = 427, - SAMPLER1DSHADOW = 428, - SAMPLER2DRECT = 429, - SAMPLER2DRECTSHADOW = 430, - ISAMPLER2DRECT = 431, - USAMPLER2DRECT = 432, - SAMPLERBUFFER = 433, - ISAMPLERBUFFER = 434, - USAMPLERBUFFER = 435, - SAMPLER2DMS = 436, - ISAMPLER2DMS = 437, - USAMPLER2DMS = 438, - SAMPLER2DMSARRAY = 439, - ISAMPLER2DMSARRAY = 440, - USAMPLER2DMSARRAY = 441, - SAMPLEREXTERNALOES = 442, - SAMPLEREXTERNAL2DY2YEXT = 443, - ISAMPLER1DARRAY = 444, - USAMPLER1D = 445, - USAMPLER1DARRAY = 446, - F16SAMPLER1D = 447, - F16SAMPLER2D = 448, - F16SAMPLER3D = 449, - F16SAMPLER2DRECT = 450, - F16SAMPLERCUBE = 451, - F16SAMPLER1DARRAY = 452, - F16SAMPLER2DARRAY = 453, - F16SAMPLERCUBEARRAY = 454, - F16SAMPLERBUFFER = 455, - F16SAMPLER2DMS = 456, - F16SAMPLER2DMSARRAY = 457, - F16SAMPLER1DSHADOW = 458, - F16SAMPLER2DSHADOW = 459, - F16SAMPLER1DARRAYSHADOW = 460, - F16SAMPLER2DARRAYSHADOW = 461, - F16SAMPLER2DRECTSHADOW = 462, - F16SAMPLERCUBESHADOW = 463, - F16SAMPLERCUBEARRAYSHADOW = 464, - IMAGE1D = 465, - IIMAGE1D = 466, - UIMAGE1D = 467, - IMAGE2D = 468, - IIMAGE2D = 469, - UIMAGE2D = 470, - IMAGE3D = 471, - IIMAGE3D = 472, - UIMAGE3D = 473, - IMAGE2DRECT = 474, - IIMAGE2DRECT = 475, - UIMAGE2DRECT = 476, - IMAGECUBE = 477, - IIMAGECUBE = 478, - UIMAGECUBE = 479, - IMAGEBUFFER = 480, - IIMAGEBUFFER = 481, - UIMAGEBUFFER = 482, - IMAGE1DARRAY = 483, - IIMAGE1DARRAY = 484, - UIMAGE1DARRAY = 485, - IMAGE2DARRAY = 486, - IIMAGE2DARRAY = 487, - UIMAGE2DARRAY = 488, - IMAGECUBEARRAY = 489, - IIMAGECUBEARRAY = 490, - UIMAGECUBEARRAY = 491, - IMAGE2DMS = 492, - IIMAGE2DMS = 493, - UIMAGE2DMS = 494, - IMAGE2DMSARRAY = 495, - IIMAGE2DMSARRAY = 496, - UIMAGE2DMSARRAY = 497, - F16IMAGE1D = 498, - F16IMAGE2D = 499, - F16IMAGE3D = 500, - F16IMAGE2DRECT = 501, - F16IMAGECUBE = 502, - F16IMAGE1DARRAY = 503, - F16IMAGE2DARRAY = 504, - F16IMAGECUBEARRAY = 505, - F16IMAGEBUFFER = 506, - F16IMAGE2DMS = 507, - F16IMAGE2DMSARRAY = 508, - TEXTURECUBEARRAY = 509, - ITEXTURECUBEARRAY = 510, - UTEXTURECUBEARRAY = 511, - TEXTURE1D = 512, - ITEXTURE1D = 513, - UTEXTURE1D = 514, - TEXTURE1DARRAY = 515, - ITEXTURE1DARRAY = 516, - UTEXTURE1DARRAY = 517, - TEXTURE2DRECT = 518, - ITEXTURE2DRECT = 519, - UTEXTURE2DRECT = 520, - TEXTUREBUFFER = 521, - ITEXTUREBUFFER = 522, - UTEXTUREBUFFER = 523, - TEXTURE2DMS = 524, - ITEXTURE2DMS = 525, - UTEXTURE2DMS = 526, - TEXTURE2DMSARRAY = 527, - ITEXTURE2DMSARRAY = 528, - UTEXTURE2DMSARRAY = 529, - F16TEXTURE1D = 530, - F16TEXTURE2D = 531, - F16TEXTURE3D = 532, - F16TEXTURE2DRECT = 533, - F16TEXTURECUBE = 534, - F16TEXTURE1DARRAY = 535, - F16TEXTURE2DARRAY = 536, - F16TEXTURECUBEARRAY = 537, - F16TEXTUREBUFFER = 538, - F16TEXTURE2DMS = 539, - F16TEXTURE2DMSARRAY = 540, - SUBPASSINPUT = 541, - SUBPASSINPUTMS = 542, - ISUBPASSINPUT = 543, - ISUBPASSINPUTMS = 544, - USUBPASSINPUT = 545, - USUBPASSINPUTMS = 546, - F16SUBPASSINPUT = 547, - F16SUBPASSINPUTMS = 548, - LEFT_OP = 549, - RIGHT_OP = 550, - INC_OP = 551, - DEC_OP = 552, - LE_OP = 553, - GE_OP = 554, - EQ_OP = 555, - NE_OP = 556, - AND_OP = 557, - OR_OP = 558, - XOR_OP = 559, - MUL_ASSIGN = 560, - DIV_ASSIGN = 561, - ADD_ASSIGN = 562, - MOD_ASSIGN = 563, - LEFT_ASSIGN = 564, - RIGHT_ASSIGN = 565, - AND_ASSIGN = 566, - XOR_ASSIGN = 567, - OR_ASSIGN = 568, - SUB_ASSIGN = 569, - STRING_LITERAL = 570, - LEFT_PAREN = 571, - RIGHT_PAREN = 572, - LEFT_BRACKET = 573, - RIGHT_BRACKET = 574, - LEFT_BRACE = 575, - RIGHT_BRACE = 576, - DOT = 577, - COMMA = 578, - COLON = 579, - EQUAL = 580, - SEMICOLON = 581, - BANG = 582, - DASH = 583, - TILDE = 584, - PLUS = 585, - STAR = 586, - SLASH = 587, - PERCENT = 588, - LEFT_ANGLE = 589, - RIGHT_ANGLE = 590, - VERTICAL_BAR = 591, - CARET = 592, - AMPERSAND = 593, - QUESTION = 594, - INVARIANT = 595, - HIGH_PRECISION = 596, - MEDIUM_PRECISION = 597, - LOW_PRECISION = 598, - PRECISION = 599, - PACKED = 600, - RESOURCE = 601, - SUPERP = 602, - FLOATCONSTANT = 603, - INTCONSTANT = 604, - UINTCONSTANT = 605, - BOOLCONSTANT = 606, - IDENTIFIER = 607, - TYPE_NAME = 608, - CENTROID = 609, - IN = 610, - OUT = 611, - INOUT = 612, - STRUCT = 613, - VOID = 614, - WHILE = 615, - BREAK = 616, - CONTINUE = 617, - DO = 618, - ELSE = 619, - FOR = 620, - IF = 621, - DISCARD = 622, - RETURN = 623, - SWITCH = 624, - CASE = 625, - DEFAULT = 626, - UNIFORM = 627, - SHARED = 628, - BUFFER = 629, - FLAT = 630, - SMOOTH = 631, - LAYOUT = 632, - DOUBLECONSTANT = 633, - INT16CONSTANT = 634, - UINT16CONSTANT = 635, - FLOAT16CONSTANT = 636, - INT32CONSTANT = 637, - UINT32CONSTANT = 638, - INT64CONSTANT = 639, - UINT64CONSTANT = 640, - SUBROUTINE = 641, - DEMOTE = 642, - PAYLOADNV = 643, - PAYLOADINNV = 644, - HITATTRNV = 645, - CALLDATANV = 646, - CALLDATAINNV = 647, - PAYLOADEXT = 648, - PAYLOADINEXT = 649, - HITATTREXT = 650, - CALLDATAEXT = 651, - CALLDATAINEXT = 652, - PATCH = 653, - SAMPLE = 654, - NONUNIFORM = 655, - COHERENT = 656, - VOLATILE = 657, - RESTRICT = 658, - READONLY = 659, - WRITEONLY = 660, - DEVICECOHERENT = 661, - QUEUEFAMILYCOHERENT = 662, - WORKGROUPCOHERENT = 663, - SUBGROUPCOHERENT = 664, - NONPRIVATE = 665, - SHADERCALLCOHERENT = 666, - NOPERSPECTIVE = 667, - EXPLICITINTERPAMD = 668, - PERVERTEXNV = 669, - PERPRIMITIVENV = 670, - PERVIEWNV = 671, - PERTASKNV = 672, - PRECISE = 673 + RAYQUERYEXT = 417, + FCOOPMATNV = 418, + ICOOPMATNV = 419, + UCOOPMATNV = 420, + SAMPLERCUBEARRAY = 421, + SAMPLERCUBEARRAYSHADOW = 422, + ISAMPLERCUBEARRAY = 423, + USAMPLERCUBEARRAY = 424, + SAMPLER1D = 425, + SAMPLER1DARRAY = 426, + SAMPLER1DARRAYSHADOW = 427, + ISAMPLER1D = 428, + SAMPLER1DSHADOW = 429, + SAMPLER2DRECT = 430, + SAMPLER2DRECTSHADOW = 431, + ISAMPLER2DRECT = 432, + USAMPLER2DRECT = 433, + SAMPLERBUFFER = 434, + ISAMPLERBUFFER = 435, + USAMPLERBUFFER = 436, + SAMPLER2DMS = 437, + ISAMPLER2DMS = 438, + USAMPLER2DMS = 439, + SAMPLER2DMSARRAY = 440, + ISAMPLER2DMSARRAY = 441, + USAMPLER2DMSARRAY = 442, + SAMPLEREXTERNALOES = 443, + SAMPLEREXTERNAL2DY2YEXT = 444, + ISAMPLER1DARRAY = 445, + USAMPLER1D = 446, + USAMPLER1DARRAY = 447, + F16SAMPLER1D = 448, + F16SAMPLER2D = 449, + F16SAMPLER3D = 450, + F16SAMPLER2DRECT = 451, + F16SAMPLERCUBE = 452, + F16SAMPLER1DARRAY = 453, + F16SAMPLER2DARRAY = 454, + F16SAMPLERCUBEARRAY = 455, + F16SAMPLERBUFFER = 456, + F16SAMPLER2DMS = 457, + F16SAMPLER2DMSARRAY = 458, + F16SAMPLER1DSHADOW = 459, + F16SAMPLER2DSHADOW = 460, + F16SAMPLER1DARRAYSHADOW = 461, + F16SAMPLER2DARRAYSHADOW = 462, + F16SAMPLER2DRECTSHADOW = 463, + F16SAMPLERCUBESHADOW = 464, + F16SAMPLERCUBEARRAYSHADOW = 465, + IMAGE1D = 466, + IIMAGE1D = 467, + UIMAGE1D = 468, + IMAGE2D = 469, + IIMAGE2D = 470, + UIMAGE2D = 471, + IMAGE3D = 472, + IIMAGE3D = 473, + UIMAGE3D = 474, + IMAGE2DRECT = 475, + IIMAGE2DRECT = 476, + UIMAGE2DRECT = 477, + IMAGECUBE = 478, + IIMAGECUBE = 479, + UIMAGECUBE = 480, + IMAGEBUFFER = 481, + IIMAGEBUFFER = 482, + UIMAGEBUFFER = 483, + IMAGE1DARRAY = 484, + IIMAGE1DARRAY = 485, + UIMAGE1DARRAY = 486, + IMAGE2DARRAY = 487, + IIMAGE2DARRAY = 488, + UIMAGE2DARRAY = 489, + IMAGECUBEARRAY = 490, + IIMAGECUBEARRAY = 491, + UIMAGECUBEARRAY = 492, + IMAGE2DMS = 493, + IIMAGE2DMS = 494, + UIMAGE2DMS = 495, + IMAGE2DMSARRAY = 496, + IIMAGE2DMSARRAY = 497, + UIMAGE2DMSARRAY = 498, + F16IMAGE1D = 499, + F16IMAGE2D = 500, + F16IMAGE3D = 501, + F16IMAGE2DRECT = 502, + F16IMAGECUBE = 503, + F16IMAGE1DARRAY = 504, + F16IMAGE2DARRAY = 505, + F16IMAGECUBEARRAY = 506, + F16IMAGEBUFFER = 507, + F16IMAGE2DMS = 508, + F16IMAGE2DMSARRAY = 509, + TEXTURECUBEARRAY = 510, + ITEXTURECUBEARRAY = 511, + UTEXTURECUBEARRAY = 512, + TEXTURE1D = 513, + ITEXTURE1D = 514, + UTEXTURE1D = 515, + TEXTURE1DARRAY = 516, + ITEXTURE1DARRAY = 517, + UTEXTURE1DARRAY = 518, + TEXTURE2DRECT = 519, + ITEXTURE2DRECT = 520, + UTEXTURE2DRECT = 521, + TEXTUREBUFFER = 522, + ITEXTUREBUFFER = 523, + UTEXTUREBUFFER = 524, + TEXTURE2DMS = 525, + ITEXTURE2DMS = 526, + UTEXTURE2DMS = 527, + TEXTURE2DMSARRAY = 528, + ITEXTURE2DMSARRAY = 529, + UTEXTURE2DMSARRAY = 530, + F16TEXTURE1D = 531, + F16TEXTURE2D = 532, + F16TEXTURE3D = 533, + F16TEXTURE2DRECT = 534, + F16TEXTURECUBE = 535, + F16TEXTURE1DARRAY = 536, + F16TEXTURE2DARRAY = 537, + F16TEXTURECUBEARRAY = 538, + F16TEXTUREBUFFER = 539, + F16TEXTURE2DMS = 540, + F16TEXTURE2DMSARRAY = 541, + SUBPASSINPUT = 542, + SUBPASSINPUTMS = 543, + ISUBPASSINPUT = 544, + ISUBPASSINPUTMS = 545, + USUBPASSINPUT = 546, + USUBPASSINPUTMS = 547, + F16SUBPASSINPUT = 548, + F16SUBPASSINPUTMS = 549, + LEFT_OP = 550, + RIGHT_OP = 551, + INC_OP = 552, + DEC_OP = 553, + LE_OP = 554, + GE_OP = 555, + EQ_OP = 556, + NE_OP = 557, + AND_OP = 558, + OR_OP = 559, + XOR_OP = 560, + MUL_ASSIGN = 561, + DIV_ASSIGN = 562, + ADD_ASSIGN = 563, + MOD_ASSIGN = 564, + LEFT_ASSIGN = 565, + RIGHT_ASSIGN = 566, + AND_ASSIGN = 567, + XOR_ASSIGN = 568, + OR_ASSIGN = 569, + SUB_ASSIGN = 570, + STRING_LITERAL = 571, + LEFT_PAREN = 572, + RIGHT_PAREN = 573, + LEFT_BRACKET = 574, + RIGHT_BRACKET = 575, + LEFT_BRACE = 576, + RIGHT_BRACE = 577, + DOT = 578, + COMMA = 579, + COLON = 580, + EQUAL = 581, + SEMICOLON = 582, + BANG = 583, + DASH = 584, + TILDE = 585, + PLUS = 586, + STAR = 587, + SLASH = 588, + PERCENT = 589, + LEFT_ANGLE = 590, + RIGHT_ANGLE = 591, + VERTICAL_BAR = 592, + CARET = 593, + AMPERSAND = 594, + QUESTION = 595, + INVARIANT = 596, + HIGH_PRECISION = 597, + MEDIUM_PRECISION = 598, + LOW_PRECISION = 599, + PRECISION = 600, + PACKED = 601, + RESOURCE = 602, + SUPERP = 603, + FLOATCONSTANT = 604, + INTCONSTANT = 605, + UINTCONSTANT = 606, + BOOLCONSTANT = 607, + IDENTIFIER = 608, + TYPE_NAME = 609, + CENTROID = 610, + IN = 611, + OUT = 612, + INOUT = 613, + STRUCT = 614, + VOID = 615, + WHILE = 616, + BREAK = 617, + CONTINUE = 618, + DO = 619, + ELSE = 620, + FOR = 621, + IF = 622, + DISCARD = 623, + RETURN = 624, + SWITCH = 625, + CASE = 626, + DEFAULT = 627, + UNIFORM = 628, + SHARED = 629, + BUFFER = 630, + FLAT = 631, + SMOOTH = 632, + LAYOUT = 633, + DOUBLECONSTANT = 634, + INT16CONSTANT = 635, + UINT16CONSTANT = 636, + FLOAT16CONSTANT = 637, + INT32CONSTANT = 638, + UINT32CONSTANT = 639, + INT64CONSTANT = 640, + UINT64CONSTANT = 641, + SUBROUTINE = 642, + DEMOTE = 643, + PAYLOADNV = 644, + PAYLOADINNV = 645, + HITATTRNV = 646, + CALLDATANV = 647, + CALLDATAINNV = 648, + PAYLOADEXT = 649, + PAYLOADINEXT = 650, + HITATTREXT = 651, + CALLDATAEXT = 652, + CALLDATAINEXT = 653, + PATCH = 654, + SAMPLE = 655, + NONUNIFORM = 656, + COHERENT = 657, + VOLATILE = 658, + RESTRICT = 659, + READONLY = 660, + WRITEONLY = 661, + DEVICECOHERENT = 662, + QUEUEFAMILYCOHERENT = 663, + WORKGROUPCOHERENT = 664, + SUBGROUPCOHERENT = 665, + NONPRIVATE = 666, + SHADERCALLCOHERENT = 667, + NOPERSPECTIVE = 668, + EXPLICITINTERPAMD = 669, + PERVERTEXNV = 670, + PERPRIMITIVENV = 671, + PERVIEWNV = 672, + PERTASKNV = 673, + PRECISE = 674 }; #endif @@ -547,7 +548,7 @@ extern int yydebug; union YYSTYPE { -#line 96 "MachineIndependent/glslang.y" /* yacc.c:355 */ +#line 97 "glslang.y" /* yacc.c:355 */ struct { glslang::TSourceLoc loc; @@ -583,7 +584,7 @@ union YYSTYPE glslang::TArraySizes* typeParameters; } interm; -#line 587 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355 */ +#line 588 "glslang_tab.cpp" /* yacc.c:355 */ }; typedef union YYSTYPE YYSTYPE; @@ -595,10 +596,10 @@ typedef union YYSTYPE YYSTYPE; int yyparse (glslang::TParseContext* pParseContext); -#endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED */ +#endif /* !YY_YY_GLSLANG_TAB_CPP_H_INCLUDED */ /* Copy the second part of user declarations. */ -#line 132 "MachineIndependent/glslang.y" /* yacc.c:358 */ +#line 133 "glslang.y" /* yacc.c:358 */ /* windows only pragma */ @@ -614,7 +615,7 @@ int yyparse (glslang::TParseContext* pParseContext); extern int yylex(YYSTYPE*, TParseContext&); -#line 618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358 */ +#line 619 "glslang_tab.cpp" /* yacc.c:358 */ #ifdef short # undef short @@ -854,23 +855,23 @@ union yyalloc #endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ -#define YYFINAL 393 +#define YYFINAL 394 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 9528 +#define YYLAST 9550 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 419 +#define YYNTOKENS 420 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 111 /* YYNRULES -- Number of rules. */ -#define YYNRULES 590 +#define YYNRULES 591 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 735 +#define YYNSTATES 736 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 673 +#define YYMAXUTOK 674 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) @@ -946,73 +947,73 @@ static const yytype_uint16 yytranslate[] = 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418 + 415, 416, 417, 418, 419 }; #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { - 0, 355, 355, 361, 364, 369, 372, 375, 379, 383, - 386, 390, 394, 398, 402, 406, 410, 416, 424, 427, - 430, 433, 436, 441, 449, 456, 463, 469, 473, 480, - 483, 489, 496, 506, 514, 519, 547, 556, 562, 566, - 570, 590, 591, 592, 593, 599, 600, 605, 610, 619, - 620, 625, 633, 634, 640, 649, 650, 655, 660, 665, - 673, 674, 683, 695, 696, 705, 706, 715, 716, 725, - 726, 734, 735, 743, 744, 752, 753, 753, 771, 772, - 788, 792, 796, 800, 805, 809, 813, 817, 821, 825, - 829, 836, 839, 850, 857, 862, 867, 874, 878, 882, - 886, 891, 896, 905, 905, 916, 920, 927, 934, 937, - 944, 952, 972, 995, 1010, 1035, 1046, 1056, 1066, 1076, - 1085, 1088, 1092, 1096, 1101, 1109, 1116, 1121, 1126, 1131, - 1140, 1150, 1177, 1186, 1193, 1201, 1208, 1215, 1223, 1233, - 1240, 1251, 1257, 1260, 1267, 1271, 1275, 1284, 1294, 1297, - 1308, 1311, 1314, 1318, 1322, 1327, 1331, 1338, 1342, 1347, - 1353, 1359, 1366, 1371, 1379, 1385, 1397, 1411, 1417, 1422, - 1430, 1438, 1446, 1454, 1462, 1470, 1478, 1486, 1493, 1500, - 1504, 1509, 1514, 1519, 1524, 1529, 1534, 1538, 1542, 1546, - 1550, 1556, 1567, 1574, 1577, 1586, 1591, 1601, 1606, 1614, - 1618, 1628, 1631, 1637, 1643, 1650, 1660, 1664, 1668, 1672, - 1677, 1681, 1686, 1691, 1696, 1701, 1706, 1711, 1716, 1721, - 1726, 1732, 1738, 1744, 1749, 1754, 1759, 1764, 1769, 1774, - 1779, 1784, 1789, 1794, 1799, 1805, 1812, 1817, 1822, 1827, - 1832, 1837, 1842, 1847, 1852, 1857, 1862, 1867, 1875, 1883, - 1891, 1897, 1903, 1909, 1915, 1921, 1927, 1933, 1939, 1945, - 1951, 1957, 1963, 1969, 1975, 1981, 1987, 1993, 1999, 2005, - 2011, 2017, 2023, 2029, 2035, 2041, 2047, 2053, 2059, 2065, - 2071, 2077, 2083, 2089, 2097, 2105, 2113, 2121, 2129, 2137, - 2145, 2153, 2161, 2169, 2177, 2185, 2191, 2197, 2203, 2209, - 2215, 2221, 2227, 2233, 2239, 2245, 2251, 2257, 2263, 2269, - 2275, 2281, 2287, 2293, 2299, 2305, 2311, 2317, 2323, 2329, - 2335, 2341, 2347, 2353, 2359, 2365, 2371, 2377, 2383, 2389, - 2395, 2401, 2405, 2409, 2414, 2420, 2425, 2430, 2435, 2440, - 2445, 2450, 2456, 2461, 2466, 2471, 2476, 2481, 2487, 2493, + 0, 357, 357, 363, 366, 371, 374, 377, 381, 385, + 388, 392, 396, 400, 404, 408, 412, 418, 426, 429, + 432, 435, 438, 443, 451, 458, 465, 471, 475, 482, + 485, 491, 498, 508, 516, 521, 549, 558, 564, 568, + 572, 592, 593, 594, 595, 601, 602, 607, 612, 621, + 622, 627, 635, 636, 642, 651, 652, 657, 662, 667, + 675, 676, 685, 697, 698, 707, 708, 717, 718, 727, + 728, 736, 737, 745, 746, 754, 755, 755, 773, 774, + 790, 794, 798, 802, 807, 811, 815, 819, 823, 827, + 831, 838, 841, 852, 859, 864, 869, 876, 880, 884, + 888, 893, 898, 907, 907, 918, 922, 929, 936, 939, + 946, 954, 974, 997, 1012, 1037, 1048, 1058, 1068, 1078, + 1087, 1090, 1094, 1098, 1103, 1111, 1118, 1123, 1128, 1133, + 1142, 1152, 1179, 1188, 1195, 1203, 1210, 1217, 1225, 1235, + 1242, 1253, 1259, 1262, 1269, 1273, 1277, 1286, 1296, 1299, + 1310, 1313, 1316, 1320, 1324, 1329, 1333, 1340, 1344, 1349, + 1355, 1361, 1368, 1373, 1381, 1387, 1399, 1413, 1419, 1424, + 1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1495, 1502, + 1506, 1511, 1516, 1521, 1526, 1531, 1536, 1540, 1544, 1548, + 1552, 1558, 1569, 1576, 1579, 1588, 1593, 1603, 1608, 1616, + 1620, 1630, 1633, 1639, 1645, 1652, 1662, 1666, 1670, 1674, + 1679, 1683, 1688, 1693, 1698, 1703, 1708, 1713, 1718, 1723, + 1728, 1734, 1740, 1746, 1751, 1756, 1761, 1766, 1771, 1776, + 1781, 1786, 1791, 1796, 1801, 1807, 1814, 1819, 1824, 1829, + 1834, 1839, 1844, 1849, 1854, 1859, 1864, 1869, 1877, 1885, + 1893, 1899, 1905, 1911, 1917, 1923, 1929, 1935, 1941, 1947, + 1953, 1959, 1965, 1971, 1977, 1983, 1989, 1995, 2001, 2007, + 2013, 2019, 2025, 2031, 2037, 2043, 2049, 2055, 2061, 2067, + 2073, 2079, 2085, 2091, 2099, 2107, 2115, 2123, 2131, 2139, + 2147, 2155, 2163, 2171, 2179, 2187, 2193, 2199, 2205, 2211, + 2217, 2223, 2229, 2235, 2241, 2247, 2253, 2259, 2265, 2271, + 2277, 2283, 2289, 2295, 2301, 2307, 2313, 2319, 2325, 2331, + 2337, 2343, 2349, 2355, 2361, 2367, 2373, 2379, 2385, 2391, + 2397, 2403, 2407, 2411, 2415, 2420, 2426, 2431, 2436, 2441, + 2446, 2451, 2456, 2462, 2467, 2472, 2477, 2482, 2487, 2493, 2499, 2505, 2511, 2517, 2523, 2529, 2535, 2541, 2547, 2553, - 2559, 2565, 2570, 2575, 2580, 2585, 2590, 2595, 2601, 2606, - 2611, 2616, 2621, 2626, 2631, 2636, 2642, 2647, 2652, 2657, - 2662, 2667, 2672, 2677, 2682, 2687, 2692, 2697, 2702, 2707, - 2712, 2718, 2723, 2728, 2734, 2740, 2745, 2750, 2755, 2761, - 2766, 2771, 2776, 2782, 2787, 2792, 2797, 2803, 2808, 2813, - 2818, 2824, 2830, 2836, 2842, 2847, 2853, 2859, 2865, 2870, - 2875, 2880, 2885, 2890, 2896, 2901, 2906, 2911, 2917, 2922, - 2927, 2932, 2938, 2943, 2948, 2953, 2959, 2964, 2969, 2974, - 2980, 2985, 2990, 2995, 3001, 3006, 3011, 3016, 3022, 3027, - 3032, 3037, 3043, 3048, 3053, 3058, 3064, 3069, 3074, 3079, - 3085, 3090, 3095, 3100, 3106, 3111, 3116, 3121, 3127, 3132, - 3137, 3142, 3148, 3153, 3158, 3163, 3169, 3174, 3179, 3184, - 3190, 3195, 3200, 3206, 3212, 3218, 3224, 3231, 3238, 3244, - 3250, 3256, 3262, 3268, 3274, 3281, 3286, 3302, 3307, 3312, - 3320, 3320, 3331, 3331, 3341, 3344, 3357, 3379, 3406, 3410, - 3416, 3421, 3432, 3436, 3442, 3453, 3456, 3463, 3467, 3468, - 3474, 3475, 3476, 3477, 3478, 3479, 3480, 3482, 3488, 3497, - 3498, 3502, 3498, 3514, 3515, 3519, 3519, 3526, 3526, 3540, - 3543, 3551, 3559, 3570, 3571, 3575, 3579, 3586, 3593, 3597, - 3605, 3609, 3622, 3626, 3633, 3633, 3653, 3656, 3662, 3674, - 3686, 3690, 3697, 3697, 3712, 3712, 3728, 3728, 3749, 3752, - 3758, 3761, 3767, 3771, 3778, 3783, 3788, 3795, 3798, 3807, - 3811, 3820, 3823, 3827, 3836, 3836, 3859, 3865, 3868, 3873, - 3876 + 2559, 2565, 2571, 2576, 2581, 2586, 2591, 2596, 2601, 2607, + 2612, 2617, 2622, 2627, 2632, 2637, 2642, 2648, 2653, 2658, + 2663, 2668, 2673, 2678, 2683, 2688, 2693, 2698, 2703, 2708, + 2713, 2718, 2724, 2729, 2734, 2740, 2746, 2751, 2756, 2761, + 2767, 2772, 2777, 2782, 2788, 2793, 2798, 2803, 2809, 2814, + 2819, 2824, 2830, 2836, 2842, 2848, 2853, 2859, 2865, 2871, + 2876, 2881, 2886, 2891, 2896, 2902, 2907, 2912, 2917, 2923, + 2928, 2933, 2938, 2944, 2949, 2954, 2959, 2965, 2970, 2975, + 2980, 2986, 2991, 2996, 3001, 3007, 3012, 3017, 3022, 3028, + 3033, 3038, 3043, 3049, 3054, 3059, 3064, 3070, 3075, 3080, + 3085, 3091, 3096, 3101, 3106, 3112, 3117, 3122, 3127, 3133, + 3138, 3143, 3148, 3154, 3159, 3164, 3169, 3175, 3180, 3185, + 3190, 3196, 3201, 3206, 3212, 3218, 3224, 3230, 3237, 3244, + 3250, 3256, 3262, 3268, 3274, 3280, 3287, 3292, 3308, 3313, + 3318, 3326, 3326, 3337, 3337, 3347, 3350, 3363, 3385, 3412, + 3416, 3422, 3427, 3438, 3442, 3448, 3459, 3462, 3469, 3473, + 3474, 3480, 3481, 3482, 3483, 3484, 3485, 3486, 3488, 3494, + 3503, 3504, 3508, 3504, 3520, 3521, 3525, 3525, 3532, 3532, + 3546, 3549, 3557, 3565, 3576, 3577, 3581, 3585, 3592, 3599, + 3603, 3611, 3615, 3628, 3632, 3639, 3639, 3659, 3662, 3668, + 3680, 3692, 3696, 3703, 3703, 3718, 3718, 3734, 3734, 3755, + 3758, 3764, 3767, 3773, 3777, 3784, 3789, 3794, 3801, 3804, + 3813, 3817, 3826, 3829, 3833, 3842, 3842, 3865, 3871, 3874, + 3879, 3882 }; #endif @@ -1049,16 +1050,17 @@ static const char *const yytname[] = "F32MAT3X2", "F32MAT3X3", "F32MAT3X4", "F32MAT4X2", "F32MAT4X3", "F32MAT4X4", "F64MAT2X2", "F64MAT2X3", "F64MAT2X4", "F64MAT3X2", "F64MAT3X3", "F64MAT3X4", "F64MAT4X2", "F64MAT4X3", "F64MAT4X4", - "ATOMIC_UINT", "ACCSTRUCTNV", "ACCSTRUCTEXT", "FCOOPMATNV", "ICOOPMATNV", - "UCOOPMATNV", "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", - "ISAMPLERCUBEARRAY", "USAMPLERCUBEARRAY", "SAMPLER1D", "SAMPLER1DARRAY", - "SAMPLER1DARRAYSHADOW", "ISAMPLER1D", "SAMPLER1DSHADOW", "SAMPLER2DRECT", - "SAMPLER2DRECTSHADOW", "ISAMPLER2DRECT", "USAMPLER2DRECT", - "SAMPLERBUFFER", "ISAMPLERBUFFER", "USAMPLERBUFFER", "SAMPLER2DMS", - "ISAMPLER2DMS", "USAMPLER2DMS", "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY", - "USAMPLER2DMSARRAY", "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT", - "ISAMPLER1DARRAY", "USAMPLER1D", "USAMPLER1DARRAY", "F16SAMPLER1D", - "F16SAMPLER2D", "F16SAMPLER3D", "F16SAMPLER2DRECT", "F16SAMPLERCUBE", + "ATOMIC_UINT", "ACCSTRUCTNV", "ACCSTRUCTEXT", "RAYQUERYEXT", + "FCOOPMATNV", "ICOOPMATNV", "UCOOPMATNV", "SAMPLERCUBEARRAY", + "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY", "USAMPLERCUBEARRAY", + "SAMPLER1D", "SAMPLER1DARRAY", "SAMPLER1DARRAYSHADOW", "ISAMPLER1D", + "SAMPLER1DSHADOW", "SAMPLER2DRECT", "SAMPLER2DRECTSHADOW", + "ISAMPLER2DRECT", "USAMPLER2DRECT", "SAMPLERBUFFER", "ISAMPLERBUFFER", + "USAMPLERBUFFER", "SAMPLER2DMS", "ISAMPLER2DMS", "USAMPLER2DMS", + "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY", "USAMPLER2DMSARRAY", + "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT", "ISAMPLER1DARRAY", + "USAMPLER1D", "USAMPLER1DARRAY", "F16SAMPLER1D", "F16SAMPLER2D", + "F16SAMPLER3D", "F16SAMPLER2DRECT", "F16SAMPLERCUBE", "F16SAMPLER1DARRAY", "F16SAMPLER2DARRAY", "F16SAMPLERCUBEARRAY", "F16SAMPLERBUFFER", "F16SAMPLER2DMS", "F16SAMPLER2DMSARRAY", "F16SAMPLER1DSHADOW", "F16SAMPLER2DSHADOW", "F16SAMPLER1DARRAYSHADOW", @@ -1197,16 +1199,16 @@ static const yytype_uint16 yytoknum[] = 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, - 665, 666, 667, 668, 669, 670, 671, 672, 673 + 665, 666, 667, 668, 669, 670, 671, 672, 673, 674 }; # endif -#define YYPACT_NINF -456 +#define YYPACT_NINF -457 #define yypact_value_is_default(Yystate) \ - (!!((Yystate) == (-456))) + (!!((Yystate) == (-457))) -#define YYTABLE_NINF -536 +#define YYTABLE_NINF -537 #define yytable_value_is_error(Yytable_value) \ 0 @@ -1215,80 +1217,80 @@ static const yytype_uint16 yytoknum[] = STATE-NUM. */ static const yytype_int16 yypact[] = { - 4066, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, 132, -456, -456, - -456, -456, -456, -1, -456, -456, -456, -456, -456, -456, - -300, -297, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, 11, -248, 17, 30, 6146, 20, - -456, 28, -456, -456, -456, -456, 4482, -456, -456, -456, - -456, 50, -456, -456, 738, -456, -456, 16, -456, 81, - -29, 69, -456, -312, -456, 111, -456, 6146, -456, -456, - -456, 6146, 103, 106, -456, -313, -456, 72, -456, -456, - 8546, 142, -456, -456, -456, 136, 6146, -456, 144, -456, - 53, -456, -456, 76, 6958, -456, -311, 1154, -456, -456, - -456, -456, 142, -308, -456, 7355, -307, -456, 119, -456, - 65, 8546, 8546, -456, 8546, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, 36, -456, -456, -456, 171, 85, - 8943, 173, -456, 8546, -456, -456, -322, 174, -456, 6146, - 139, 4898, -456, 6146, 8546, -456, -29, -456, 141, -456, - -456, 145, 99, 35, 26, 71, 156, 159, 161, 196, - 195, 23, 181, 7752, -456, 183, 182, -456, -456, 186, - 179, 180, -456, 191, 192, 187, 8149, 193, 8546, 188, - 189, 127, -456, -456, 96, -456, -248, 200, 201, -456, - -456, -456, -456, -456, 1570, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -24, 174, 7355, 13, 7355, -456, - -456, 7355, 6146, -456, 166, -456, -456, -456, 86, -456, - -456, 8546, 168, -456, -456, 8546, 205, -456, -456, -456, - 8546, -456, 139, 142, 124, -456, -456, -456, 5314, -456, - -456, -456, -456, 8546, 8546, 8546, 8546, 8546, 8546, 8546, - 8546, 8546, 8546, 8546, 8546, 8546, 8546, 8546, 8546, 8546, - 8546, 8546, -456, -456, -456, 206, 172, -456, 1986, -456, - -456, -456, 1986, -456, 8546, -456, -456, 130, 8546, 125, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, 8546, 8546, -456, -456, -456, -456, -456, - -456, -456, 7355, -456, 94, -456, 5730, -456, -456, 207, - 204, -456, -456, -456, 131, 174, 139, -456, -456, -456, - -456, -456, 145, 145, 99, 99, 35, 35, 35, 35, - 26, 26, 71, 156, 159, 161, 196, 195, 8546, -456, - 212, 60, -456, 1986, 3650, 169, 3234, 87, -456, 89, - -456, -456, -456, -456, -456, 6561, -456, -456, -456, -456, - 143, 8546, 211, 172, 210, 204, 184, 6146, 217, 219, - -456, -456, 3650, 218, -456, -456, -456, 8546, 220, -456, - -456, -456, 214, 2402, 8546, -456, 216, 223, 185, 224, - 2818, -456, 225, -456, -456, 7355, -456, -456, -456, 97, - 8546, 2402, 218, -456, -456, 1986, -456, 222, 204, -456, - -456, 1986, 229, -456, -456 + 4075, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, 132, -457, + -457, -457, -457, -457, -1, -457, -457, -457, -457, -457, + -457, -301, -298, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, 11, -249, 17, 30, 6160, + 20, -457, 28, -457, -457, -457, -457, 4492, -457, -457, + -457, -457, 50, -457, -457, 739, -457, -457, 16, -457, + 81, -29, 69, -457, -313, -457, 111, -457, 6160, -457, + -457, -457, 6160, 103, 106, -457, -314, -457, 72, -457, + -457, 8566, 142, -457, -457, -457, 136, 6160, -457, 144, + -457, 53, -457, -457, 76, 6974, -457, -312, 1156, -457, + -457, -457, -457, 142, -309, -457, 7372, -308, -457, 119, + -457, 65, 8566, 8566, -457, 8566, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, -457, 36, -457, -457, -457, 171, + 85, 8964, 173, -457, 8566, -457, -457, -323, 174, -457, + 6160, 139, 4909, -457, 6160, 8566, -457, -29, -457, 141, + -457, -457, 145, 99, 35, 26, 71, 156, 159, 161, + 196, 195, 23, 181, 7770, -457, 183, 182, -457, -457, + 186, 179, 180, -457, 191, 192, 187, 8168, 193, 8566, + 188, 189, 127, -457, -457, 96, -457, -249, 200, 201, + -457, -457, -457, -457, -457, 1573, -457, -457, -457, -457, + -457, -457, -457, -457, -457, -24, 174, 7372, 13, 7372, + -457, -457, 7372, 6160, -457, 166, -457, -457, -457, 86, + -457, -457, 8566, 168, -457, -457, 8566, 205, -457, -457, + -457, 8566, -457, 139, 142, 124, -457, -457, -457, 5326, + -457, -457, -457, -457, 8566, 8566, 8566, 8566, 8566, 8566, + 8566, 8566, 8566, 8566, 8566, 8566, 8566, 8566, 8566, 8566, + 8566, 8566, 8566, -457, -457, -457, 206, 172, -457, 1990, + -457, -457, -457, 1990, -457, 8566, -457, -457, 130, 8566, + 125, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, -457, -457, 8566, 8566, -457, -457, -457, -457, + -457, -457, -457, 7372, -457, 94, -457, 5743, -457, -457, + 207, 204, -457, -457, -457, 131, 174, 139, -457, -457, + -457, -457, -457, 145, 145, 99, 99, 35, 35, 35, + 35, 26, 26, 71, 156, 159, 161, 196, 195, 8566, + -457, 212, 60, -457, 1990, 3658, 169, 3241, 87, -457, + 89, -457, -457, -457, -457, -457, 6576, -457, -457, -457, + -457, 143, 8566, 211, 172, 210, 204, 184, 6160, 217, + 219, -457, -457, 3658, 218, -457, -457, -457, 8566, 220, + -457, -457, -457, 214, 2407, 8566, -457, 216, 223, 185, + 224, 2824, -457, 225, -457, -457, 7372, -457, -457, -457, + 97, 8566, 2407, 218, -457, -457, 1990, -457, 222, 204, + -457, -457, 1990, 229, -457, -457 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -1299,9 +1301,9 @@ static const yytype_uint16 yydefact[] = 0, 157, 210, 208, 209, 207, 214, 215, 216, 217, 218, 219, 220, 221, 222, 211, 212, 213, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 335, 336, 337, 338, 339, 340, 341, 361, 362, 363, - 364, 365, 366, 367, 376, 389, 390, 377, 378, 380, - 379, 381, 382, 383, 384, 385, 386, 387, 388, 165, + 336, 337, 338, 339, 340, 341, 342, 362, 363, 364, + 365, 366, 367, 368, 377, 390, 391, 378, 379, 381, + 380, 382, 383, 384, 385, 386, 387, 388, 389, 165, 166, 236, 237, 235, 238, 245, 246, 243, 244, 241, 242, 239, 240, 268, 269, 270, 280, 281, 282, 265, 266, 267, 277, 278, 279, 262, 263, 264, 274, 275, @@ -1311,99 +1313,99 @@ static const yytype_uint16 yydefact[] = 321, 286, 287, 288, 289, 290, 291, 292, 293, 294, 298, 299, 300, 301, 302, 303, 304, 305, 306, 310, 311, 312, 313, 314, 315, 316, 317, 318, 322, 323, - 324, 325, 326, 327, 328, 329, 330, 333, 331, 332, - 492, 493, 494, 345, 346, 369, 372, 334, 343, 344, - 360, 342, 391, 392, 395, 396, 397, 399, 400, 401, - 403, 404, 405, 407, 408, 482, 483, 368, 370, 371, - 347, 348, 349, 393, 350, 354, 355, 358, 398, 402, - 406, 351, 352, 356, 357, 394, 353, 359, 438, 440, - 441, 442, 444, 445, 446, 448, 449, 450, 452, 453, - 454, 456, 457, 458, 460, 461, 462, 464, 465, 466, - 468, 469, 470, 472, 473, 474, 476, 477, 478, 480, - 481, 439, 443, 447, 451, 455, 463, 467, 471, 459, - 475, 479, 373, 374, 375, 409, 418, 420, 414, 419, - 421, 422, 424, 425, 426, 428, 429, 430, 432, 433, - 434, 436, 437, 410, 411, 412, 423, 413, 415, 416, - 417, 427, 431, 435, 484, 485, 488, 489, 490, 491, - 486, 487, 583, 132, 497, 498, 499, 0, 496, 161, - 159, 160, 158, 0, 206, 162, 163, 164, 134, 133, - 0, 190, 171, 173, 169, 175, 177, 172, 174, 170, - 176, 178, 167, 168, 192, 179, 186, 187, 188, 189, - 180, 181, 182, 183, 184, 185, 135, 136, 137, 138, - 139, 140, 147, 582, 0, 584, 0, 109, 108, 0, - 120, 125, 154, 153, 151, 155, 0, 148, 150, 156, - 130, 202, 152, 495, 0, 579, 581, 0, 502, 0, - 0, 0, 97, 0, 94, 0, 107, 0, 116, 110, - 118, 0, 119, 0, 95, 126, 100, 0, 149, 131, - 0, 195, 201, 1, 580, 0, 0, 500, 144, 146, - 0, 142, 193, 0, 0, 98, 0, 0, 585, 111, - 115, 117, 113, 121, 112, 0, 127, 103, 0, 101, - 0, 0, 0, 9, 0, 43, 42, 44, 41, 5, - 6, 7, 8, 2, 16, 14, 15, 17, 10, 11, - 12, 13, 3, 18, 37, 20, 25, 26, 0, 0, - 30, 0, 204, 0, 36, 34, 0, 196, 96, 0, - 0, 0, 504, 0, 0, 141, 0, 191, 0, 197, - 45, 49, 52, 55, 60, 63, 65, 67, 69, 71, - 73, 75, 0, 0, 99, 0, 530, 539, 543, 0, - 0, 0, 564, 0, 0, 0, 0, 0, 0, 0, - 0, 45, 78, 91, 0, 517, 0, 156, 130, 520, - 541, 519, 527, 518, 0, 521, 522, 545, 523, 552, - 524, 525, 560, 526, 0, 114, 0, 122, 0, 512, - 129, 0, 0, 105, 0, 102, 38, 39, 0, 22, - 23, 0, 0, 28, 27, 0, 206, 31, 33, 40, - 0, 203, 0, 510, 0, 508, 503, 505, 0, 93, - 145, 143, 194, 0, 0, 0, 0, 0, 0, 0, + 324, 325, 326, 327, 328, 329, 330, 334, 331, 332, + 333, 493, 494, 495, 346, 347, 370, 373, 335, 344, + 345, 361, 343, 392, 393, 396, 397, 398, 400, 401, + 402, 404, 405, 406, 408, 409, 483, 484, 369, 371, + 372, 348, 349, 350, 394, 351, 355, 356, 359, 399, + 403, 407, 352, 353, 357, 358, 395, 354, 360, 439, + 441, 442, 443, 445, 446, 447, 449, 450, 451, 453, + 454, 455, 457, 458, 459, 461, 462, 463, 465, 466, + 467, 469, 470, 471, 473, 474, 475, 477, 478, 479, + 481, 482, 440, 444, 448, 452, 456, 464, 468, 472, + 460, 476, 480, 374, 375, 376, 410, 419, 421, 415, + 420, 422, 423, 425, 426, 427, 429, 430, 431, 433, + 434, 435, 437, 438, 411, 412, 413, 424, 414, 416, + 417, 418, 428, 432, 436, 485, 486, 489, 490, 491, + 492, 487, 488, 584, 132, 498, 499, 500, 0, 497, + 161, 159, 160, 158, 0, 206, 162, 163, 164, 134, + 133, 0, 190, 171, 173, 169, 175, 177, 172, 174, + 170, 176, 178, 167, 168, 192, 179, 186, 187, 188, + 189, 180, 181, 182, 183, 184, 185, 135, 136, 137, + 138, 139, 140, 147, 583, 0, 585, 0, 109, 108, + 0, 120, 125, 154, 153, 151, 155, 0, 148, 150, + 156, 130, 202, 152, 496, 0, 580, 582, 0, 503, + 0, 0, 0, 97, 0, 94, 0, 107, 0, 116, + 110, 118, 0, 119, 0, 95, 126, 100, 0, 149, + 131, 0, 195, 201, 1, 581, 0, 0, 501, 144, + 146, 0, 142, 193, 0, 0, 98, 0, 0, 586, + 111, 115, 117, 113, 121, 112, 0, 127, 103, 0, + 101, 0, 0, 0, 9, 0, 43, 42, 44, 41, + 5, 6, 7, 8, 2, 16, 14, 15, 17, 10, + 11, 12, 13, 3, 18, 37, 20, 25, 26, 0, + 0, 30, 0, 204, 0, 36, 34, 0, 196, 96, + 0, 0, 0, 505, 0, 0, 141, 0, 191, 0, + 197, 45, 49, 52, 55, 60, 63, 65, 67, 69, + 71, 73, 75, 0, 0, 99, 0, 531, 540, 544, + 0, 0, 0, 565, 0, 0, 0, 0, 0, 0, + 0, 0, 45, 78, 91, 0, 518, 0, 156, 130, + 521, 542, 520, 528, 519, 0, 522, 523, 546, 524, + 553, 525, 526, 561, 527, 0, 114, 0, 122, 0, + 513, 129, 0, 0, 105, 0, 102, 38, 39, 0, + 22, 23, 0, 0, 28, 27, 0, 206, 31, 33, + 40, 0, 203, 0, 511, 0, 509, 504, 506, 0, + 93, 145, 143, 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 76, 198, 199, 0, 0, 529, 0, 562, - 575, 574, 0, 566, 0, 578, 576, 0, 0, 0, - 559, 528, 81, 82, 84, 83, 86, 87, 88, 89, - 90, 85, 80, 0, 0, 544, 540, 542, 546, 553, - 561, 124, 0, 515, 0, 128, 0, 106, 4, 0, - 24, 21, 32, 205, 0, 511, 0, 506, 501, 46, - 47, 48, 51, 50, 53, 54, 58, 59, 56, 57, - 61, 62, 64, 66, 68, 70, 72, 74, 0, 200, - 589, 0, 587, 531, 0, 0, 0, 0, 577, 0, - 558, 79, 92, 123, 513, 0, 104, 19, 507, 509, - 0, 0, 0, 0, 0, 550, 0, 0, 0, 0, - 569, 568, 571, 537, 554, 514, 516, 0, 0, 586, - 588, 532, 0, 0, 0, 570, 0, 0, 549, 0, - 0, 547, 0, 77, 590, 0, 534, 563, 533, 0, - 572, 0, 537, 536, 538, 556, 551, 0, 573, 567, - 548, 557, 0, 565, 555 + 0, 0, 0, 76, 198, 199, 0, 0, 530, 0, + 563, 576, 575, 0, 567, 0, 579, 577, 0, 0, + 0, 560, 529, 81, 82, 84, 83, 86, 87, 88, + 89, 90, 85, 80, 0, 0, 545, 541, 543, 547, + 554, 562, 124, 0, 516, 0, 128, 0, 106, 4, + 0, 24, 21, 32, 205, 0, 512, 0, 507, 502, + 46, 47, 48, 51, 50, 53, 54, 58, 59, 56, + 57, 61, 62, 64, 66, 68, 70, 72, 74, 0, + 200, 590, 0, 588, 532, 0, 0, 0, 0, 578, + 0, 559, 79, 92, 123, 514, 0, 104, 19, 508, + 510, 0, 0, 0, 0, 0, 551, 0, 0, 0, + 0, 570, 569, 572, 538, 555, 515, 517, 0, 0, + 587, 589, 533, 0, 0, 0, 571, 0, 0, 550, + 0, 0, 548, 0, 77, 591, 0, 535, 564, 534, + 0, 573, 0, 538, 537, 539, 557, 552, 0, 574, + 568, 549, 558, 0, 566, 556 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, 8847, -456, -87, -84, -127, -93, -33, -31, - -27, -25, -28, -26, -456, -86, -456, -103, -456, -111, - -125, 2, -456, -456, -456, 4, -456, -456, -456, 176, - 194, 178, -456, -456, -337, -456, -456, -456, -456, 95, - -456, -37, -46, -456, 9, -456, 0, -63, -456, -456, - -456, -456, 263, -456, -456, -456, -455, -140, 10, -73, - -211, -456, -102, -198, -321, -456, -144, -456, -456, -155, - -154, -456, -456, 198, -274, -97, -456, 46, -456, -118, - -456, 51, -456, -456, -456, -456, 52, -456, -456, -456, - -456, -456, -456, -456, -456, 213, -456, -456, -456, -456, + -457, -457, -457, -457, -457, -457, -457, -457, -457, -457, + -457, -457, 8868, -457, -87, -84, -127, -93, -33, -31, + -27, -25, -28, -26, -457, -86, -457, -103, -457, -111, + -125, 2, -457, -457, -457, 4, -457, -457, -457, 176, + 194, 178, -457, -457, -337, -457, -457, -457, -457, 95, + -457, -37, -46, -457, 9, -457, 0, -63, -457, -457, + -457, -457, 263, -457, -457, -457, -456, -140, 10, -73, + -211, -457, -102, -198, -321, -457, -144, -457, -457, -155, + -154, -457, -457, 198, -274, -97, -457, 46, -457, -118, + -457, 51, -457, -457, -457, -457, 52, -457, -457, -457, + -457, -457, -457, -457, -457, 213, -457, -457, -457, -457, -105 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 442, 443, 444, 629, 445, 446, 447, 448, 449, - 450, 451, 501, 453, 471, 472, 473, 474, 475, 476, - 477, 478, 479, 480, 481, 502, 658, 503, 613, 504, - 560, 505, 344, 532, 420, 506, 346, 347, 348, 378, - 379, 380, 349, 350, 351, 352, 353, 354, 400, 401, - 355, 356, 357, 358, 454, 403, 455, 406, 391, 392, - 456, 361, 362, 363, 463, 396, 461, 462, 554, 555, - 530, 624, 509, 510, 511, 512, 513, 588, 684, 717, - 708, 709, 710, 718, 514, 515, 516, 517, 711, 688, - 518, 519, 712, 732, 520, 521, 522, 664, 592, 666, - 692, 706, 707, 523, 364, 365, 366, 375, 524, 661, - 662 + -1, 443, 444, 445, 630, 446, 447, 448, 449, 450, + 451, 452, 502, 454, 472, 473, 474, 475, 476, 477, + 478, 479, 480, 481, 482, 503, 659, 504, 614, 505, + 561, 506, 345, 533, 421, 507, 347, 348, 349, 379, + 380, 381, 350, 351, 352, 353, 354, 355, 401, 402, + 356, 357, 358, 359, 455, 404, 456, 407, 392, 393, + 457, 362, 363, 364, 464, 397, 462, 463, 555, 556, + 531, 625, 510, 511, 512, 513, 514, 589, 685, 718, + 709, 710, 711, 719, 515, 516, 517, 518, 712, 689, + 519, 520, 713, 733, 521, 522, 523, 665, 593, 667, + 693, 707, 708, 524, 365, 366, 367, 376, 525, 662, + 663 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -1411,14 +1413,14 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 360, 550, 343, 414, 345, 404, 404, 483, 558, 359, - 404, 483, 415, 551, 405, 484, 370, 526, 531, 371, + 361, 551, 344, 415, 346, 405, 405, 484, 559, 360, + 405, 484, 416, 552, 406, 485, 371, 527, 532, 372, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 626, 374, 61, + 52, 53, 54, 55, 56, 57, 58, 627, 375, 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, @@ -1442,174 +1444,91 @@ static const yytype_int16 yytable[] = 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, - 388, 381, 529, 538, 663, 621, 617, 623, 482, 368, - 625, 557, 416, 398, 570, 571, 581, 686, 457, 568, - 569, 483, 539, 540, 376, 388, 489, 372, 622, 492, - 381, 493, 494, 383, 399, 497, 384, 547, 382, 525, - 527, 369, -35, 377, 541, 686, 389, 359, 542, 459, - 572, 573, 582, 373, 360, 359, 343, 395, 345, 298, - 465, 574, 575, 359, 303, 304, 466, 382, 559, 682, - 385, 382, 716, 683, 390, 597, 359, 599, 534, 724, - 359, 535, 417, 467, 665, 418, 460, 585, 419, 468, - 716, 397, 544, 628, 693, 359, 694, 508, 545, 614, - 614, 673, 614, 388, 727, 674, 507, 675, 557, 614, - 614, 402, 615, 529, 459, 529, 459, 566, 529, 567, - 630, 407, 602, 603, 604, 605, 606, 607, 608, 609, - 610, 611, 632, 646, 647, 648, 649, 636, 614, 670, - 637, 731, 612, 614, 636, 412, 668, 678, 413, 552, - 404, 460, 458, 460, 696, 617, 614, 697, 359, 464, - 359, 533, 359, 294, 295, 296, 563, 564, 565, 642, - 643, 650, 651, 667, 644, 645, 557, 669, 543, 548, - 635, 553, 483, 562, 576, 459, 577, 578, 579, 580, - 583, 586, 589, 587, 726, 590, 591, 593, 594, 598, - 671, 672, 600, 595, 508, 601, -36, -34, 627, 529, - 631, 459, -29, 507, 660, 659, 677, 614, 681, 689, - 699, 701, 460, 617, 703, 704, 702, 714, -535, 715, - 721, 359, 720, 652, 486, 725, 653, 680, 733, 722, - 734, 654, 656, 685, 655, 657, 698, 410, 460, 411, - 367, 561, 634, 679, 690, 723, 729, 359, 730, 691, - 618, 409, 529, 408, 705, 619, 620, 394, 700, 0, - 0, 685, 0, 0, 0, 0, 0, 0, 508, 459, - 0, 0, 508, 719, 713, 559, 0, 507, 0, 0, - 0, 507, 0, 0, 0, 0, 0, 0, 0, 728, - 0, 0, 529, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 460, 687, 0, 0, - 0, 0, 0, 0, 0, 359, 0, 0, 0, 0, - 0, 388, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 687, 0, 0, 0, 0, + 292, 389, 382, 530, 539, 664, 622, 618, 624, 483, + 369, 626, 558, 417, 399, 571, 572, 582, 687, 458, + 569, 570, 484, 540, 541, 377, 389, 490, 373, 623, + 493, 382, 494, 495, 384, 400, 498, 385, 548, 383, + 526, 528, 370, -35, 378, 542, 687, 390, 360, 543, + 460, 573, 574, 583, 374, 361, 360, 344, 396, 346, + 299, 466, 575, 576, 360, 304, 305, 467, 383, 560, + 683, 386, 383, 717, 684, 391, 598, 360, 600, 535, + 725, 360, 536, 418, 468, 666, 419, 461, 586, 420, + 469, 717, 398, 545, 629, 694, 360, 695, 509, 546, + 615, 615, 674, 615, 389, 728, 675, 508, 676, 558, + 615, 615, 403, 616, 530, 460, 530, 460, 567, 530, + 568, 631, 408, 603, 604, 605, 606, 607, 608, 609, + 610, 611, 612, 633, 647, 648, 649, 650, 637, 615, + 671, 638, 732, 613, 615, 637, 413, 669, 679, 414, + 553, 405, 461, 459, 461, 697, 618, 615, 698, 360, + 465, 360, 534, 360, 295, 296, 297, 564, 565, 566, + 643, 644, 651, 652, 668, 645, 646, 558, 670, 544, + 549, 636, 554, 484, 563, 577, 460, 578, 579, 580, + 581, 584, 587, 590, 588, 727, 591, 592, 594, 595, + 599, 672, 673, 601, 596, 509, 602, -36, -34, 628, + 530, 632, 460, -29, 508, 661, 660, 678, 615, 682, + 690, 700, 702, 461, 618, 704, 705, 703, 715, -536, + 716, 722, 360, 721, 653, 487, 726, 654, 681, 734, + 723, 735, 655, 657, 686, 656, 658, 699, 411, 461, + 412, 368, 562, 635, 680, 691, 724, 730, 360, 731, + 692, 619, 410, 530, 409, 706, 620, 621, 395, 701, + 0, 0, 686, 0, 0, 0, 0, 0, 0, 509, + 460, 0, 0, 509, 720, 714, 560, 0, 508, 0, + 0, 0, 508, 0, 0, 0, 0, 0, 0, 0, + 729, 0, 0, 530, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 461, 688, 0, + 0, 0, 0, 0, 0, 0, 360, 0, 0, 0, + 0, 0, 389, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 688, 0, 0, 0, + 0, 0, 0, 0, 509, 509, 0, 509, 0, 0, 0, 0, 0, 508, 508, 0, 508, 0, 0, 0, - 0, 0, 507, 507, 0, 507, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 389, 0, 0, - 0, 0, 508, 0, 0, 0, 359, 0, 0, 0, - 0, 507, 0, 508, 0, 0, 0, 0, 0, 0, - 508, 0, 507, 0, 0, 0, 0, 0, 0, 507, - 0, 508, 0, 0, 0, 508, 0, 0, 0, 0, - 507, 508, 0, 0, 507, 0, 0, 0, 393, 0, - 507, 1, 2, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 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, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 390, 0, + 0, 0, 0, 509, 0, 0, 0, 360, 0, 0, + 0, 0, 508, 0, 509, 0, 0, 0, 0, 0, + 0, 509, 0, 508, 0, 0, 0, 0, 0, 0, + 508, 0, 509, 0, 0, 0, 509, 0, 0, 0, + 0, 508, 509, 0, 0, 508, 0, 0, 0, 394, + 0, 508, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 292, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 293, 294, - 295, 296, 297, 0, 0, 0, 0, 0, 0, 0, - 0, 298, 299, 300, 301, 302, 303, 304, 0, 0, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 305, 306, 307, 308, 309, 310, 0, 0, 0, 0, - 0, 0, 0, 0, 311, 0, 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, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 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, 0, 0, - 421, 422, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 423, - 424, 0, 485, 0, 486, 487, 0, 0, 0, 0, - 488, 425, 426, 427, 428, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 293, 294, 295, 296, 297, 0, - 0, 0, 429, 430, 431, 432, 433, 298, 299, 300, - 301, 302, 303, 304, 489, 490, 491, 492, 0, 493, - 494, 495, 496, 497, 498, 499, 305, 306, 307, 308, - 309, 310, 434, 435, 436, 437, 438, 439, 440, 441, - 311, 500, 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, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 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, 0, 0, 421, 422, 0, 0, + 294, 295, 296, 297, 298, 0, 0, 0, 0, 0, + 0, 0, 0, 299, 300, 301, 302, 303, 304, 305, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 423, 424, 0, 485, 0, - 486, 616, 0, 0, 0, 0, 488, 425, 426, 427, - 428, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 293, 294, 295, 296, 297, 0, 0, 0, 429, 430, - 431, 432, 433, 298, 299, 300, 301, 302, 303, 304, - 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, - 498, 499, 305, 306, 307, 308, 309, 310, 434, 435, - 436, 437, 438, 439, 440, 441, 311, 500, 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, + 0, 0, 306, 307, 308, 309, 310, 311, 0, 0, + 0, 0, 0, 0, 0, 0, 312, 0, 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, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, @@ -1639,144 +1558,61 @@ static const yytype_int16 yytable[] = 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, - 0, 0, 421, 422, 0, 0, 0, 0, 0, 0, + 292, 0, 0, 422, 423, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 423, 424, 0, 485, 0, 486, 0, 0, 0, - 0, 0, 488, 425, 426, 427, 428, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 293, 294, 295, 296, - 297, 0, 0, 0, 429, 430, 431, 432, 433, 298, - 299, 300, 301, 302, 303, 304, 489, 490, 491, 492, - 0, 493, 494, 495, 496, 497, 498, 499, 305, 306, - 307, 308, 309, 310, 434, 435, 436, 437, 438, 439, - 440, 441, 311, 500, 312, 313, 314, 315, 316, 317, + 0, 0, 424, 425, 0, 486, 0, 487, 488, 0, + 0, 0, 0, 489, 426, 427, 428, 429, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 294, 295, 296, + 297, 298, 0, 0, 0, 430, 431, 432, 433, 434, + 299, 300, 301, 302, 303, 304, 305, 490, 491, 492, + 493, 0, 494, 495, 496, 497, 498, 499, 500, 306, + 307, 308, 309, 310, 311, 435, 436, 437, 438, 439, + 440, 441, 442, 312, 501, 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, 2, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 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, 0, 0, 421, 422, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 423, 424, 0, - 485, 0, 407, 0, 0, 0, 0, 0, 488, 425, - 426, 427, 428, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 293, 294, 295, 296, 297, 0, 0, 0, - 429, 430, 431, 432, 433, 298, 299, 300, 301, 302, - 303, 304, 489, 490, 491, 492, 0, 493, 494, 495, - 496, 497, 498, 499, 305, 306, 307, 308, 309, 310, - 434, 435, 436, 437, 438, 439, 440, 441, 311, 500, - 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, 2, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 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, 0, 0, 421, 422, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 423, 424, 0, 485, 0, 0, 0, - 0, 0, 0, 0, 488, 425, 426, 427, 428, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 293, 294, - 295, 296, 297, 0, 0, 0, 429, 430, 431, 432, - 433, 298, 299, 300, 301, 302, 303, 304, 489, 490, - 491, 492, 0, 493, 494, 495, 496, 497, 498, 499, - 305, 306, 307, 308, 309, 310, 434, 435, 436, 437, - 438, 439, 440, 441, 311, 500, 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, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 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, 0, 0, - 421, 422, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 423, - 424, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 488, 425, 426, 427, 428, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 293, 294, 295, 296, 297, 0, - 0, 0, 429, 430, 431, 432, 433, 298, 299, 300, - 301, 302, 303, 304, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 305, 306, 307, 308, - 309, 310, 434, 435, 436, 437, 438, 439, 440, 441, - 311, 0, 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, 2, 3, 4, 5, 6, 7, + 338, 339, 340, 341, 342, 343, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 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, 0, 0, + 422, 423, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 424, + 425, 0, 486, 0, 487, 617, 0, 0, 0, 0, + 489, 426, 427, 428, 429, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 294, 295, 296, 297, 298, 0, + 0, 0, 430, 431, 432, 433, 434, 299, 300, 301, + 302, 303, 304, 305, 490, 491, 492, 493, 0, 494, + 495, 496, 497, 498, 499, 500, 306, 307, 308, 309, + 310, 311, 435, 436, 437, 438, 439, 440, 441, 442, + 312, 501, 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, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, @@ -1805,144 +1641,61 @@ static const yytype_int16 yytable[] = 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, 0, 0, 421, 422, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 423, 424, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 425, 426, 427, - 428, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 293, 294, 295, 296, 0, 0, 0, 0, 429, 430, - 431, 432, 433, 298, 299, 300, 301, 302, 303, 304, + 288, 289, 290, 291, 292, 0, 0, 422, 423, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 305, 306, 307, 308, 309, 310, 434, 435, - 436, 437, 438, 439, 440, 441, 311, 0, 312, 313, + 0, 0, 0, 0, 0, 0, 424, 425, 0, 486, + 0, 487, 0, 0, 0, 0, 0, 489, 426, 427, + 428, 429, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 295, 296, 297, 298, 0, 0, 0, 430, + 431, 432, 433, 434, 299, 300, 301, 302, 303, 304, + 305, 490, 491, 492, 493, 0, 494, 495, 496, 497, + 498, 499, 500, 306, 307, 308, 309, 310, 311, 435, + 436, 437, 438, 439, 440, 441, 442, 312, 501, 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, - 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 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, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 292, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 293, 294, 295, 296, - 297, 0, 0, 0, 0, 0, 0, 0, 0, 298, - 299, 300, 301, 302, 303, 304, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 305, 306, - 307, 308, 309, 310, 0, 0, 0, 0, 0, 0, - 0, 0, 311, 0, 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, 2, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 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, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 386, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 293, 294, 295, 296, 0, 0, 0, 0, - 0, 0, 0, 0, 387, 298, 299, 300, 301, 302, - 303, 304, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 305, 306, 307, 308, 309, 310, - 0, 0, 0, 0, 0, 0, 0, 0, 311, 0, - 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, 2, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 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, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 556, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 293, 294, - 295, 296, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 298, 299, 300, 301, 302, 303, 304, 0, 0, + 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 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, 0, 0, 422, 423, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 305, 306, 307, 308, 309, 310, 0, 0, 0, 0, - 0, 0, 0, 0, 311, 0, 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, 2, 3, + 0, 0, 0, 424, 425, 0, 486, 0, 408, 0, + 0, 0, 0, 0, 489, 426, 427, 428, 429, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 294, 295, + 296, 297, 298, 0, 0, 0, 430, 431, 432, 433, + 434, 299, 300, 301, 302, 303, 304, 305, 490, 491, + 492, 493, 0, 494, 495, 496, 497, 498, 499, 500, + 306, 307, 308, 309, 310, 311, 435, 436, 437, 438, + 439, 440, 441, 442, 312, 501, 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, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, @@ -1956,124 +1709,41 @@ static const yytype_int16 yytable[] = 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, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 638, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 293, 294, 295, 296, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 298, 299, 300, - 301, 302, 303, 304, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 305, 306, 307, 308, - 309, 310, 0, 0, 0, 0, 0, 0, 0, 0, - 311, 0, 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, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 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, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 676, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 293, 294, 295, 296, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 298, 299, 300, 301, 302, 303, 304, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 305, 306, 307, 308, 309, 310, 0, 0, - 0, 0, 0, 0, 0, 0, 311, 0, 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, - 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 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, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 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, 0, + 0, 422, 423, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 293, 294, 295, 296, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 298, - 299, 300, 301, 302, 303, 304, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 305, 306, - 307, 308, 309, 310, 0, 0, 0, 0, 0, 0, - 0, 0, 311, 0, 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, 2, 3, 4, 5, 6, + 424, 425, 0, 486, 0, 0, 0, 0, 0, 0, + 0, 489, 426, 427, 428, 429, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 294, 295, 296, 297, 298, + 0, 0, 0, 430, 431, 432, 433, 434, 299, 300, + 301, 302, 303, 304, 305, 490, 491, 492, 493, 0, + 494, 495, 496, 497, 498, 499, 500, 306, 307, 308, + 309, 310, 311, 435, 436, 437, 438, 439, 440, 441, + 442, 312, 501, 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, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 0, 0, 61, 62, 63, 64, 65, 66, + 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, @@ -2096,24 +1766,26 @@ static const yytype_int16 yytable[] = 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, 0, 0, 421, 422, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 423, 424, 0, 0, - 0, 528, 695, 0, 0, 0, 0, 0, 425, 426, - 427, 428, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 429, - 430, 431, 432, 433, 298, 0, 0, 0, 0, 303, - 304, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 434, - 435, 436, 437, 438, 439, 440, 441, 0, 0, 0, + 287, 288, 289, 290, 291, 292, 0, 0, 422, 423, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 324, 2, 3, 4, 5, 6, 7, 8, 9, + 0, 0, 0, 0, 0, 0, 0, 424, 425, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 489, 426, + 427, 428, 429, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 294, 295, 296, 297, 298, 0, 0, 0, + 430, 431, 432, 433, 434, 299, 300, 301, 302, 303, + 304, 305, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 306, 307, 308, 309, 310, 311, + 435, 436, 437, 438, 439, 440, 441, 442, 312, 0, + 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, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 0, - 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 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, @@ -2136,23 +1808,25 @@ static const yytype_int16 yytable[] = 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, 0, 0, 421, 422, 0, 0, 0, 0, + 290, 291, 292, 0, 0, 422, 423, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 423, 424, 0, 0, 469, 0, 0, - 0, 0, 0, 0, 0, 425, 426, 427, 428, 0, + 0, 0, 0, 0, 424, 425, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 426, 427, 428, 429, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 294, + 295, 296, 297, 0, 0, 0, 0, 430, 431, 432, + 433, 434, 299, 300, 301, 302, 303, 304, 305, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 429, 430, 431, 432, - 433, 298, 0, 0, 0, 0, 303, 304, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 434, 435, 436, 437, - 438, 439, 440, 441, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 324, 2, + 0, 306, 307, 308, 309, 310, 311, 435, 436, 437, + 438, 439, 440, 441, 442, 312, 0, 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, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 0, 0, 61, 62, + 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, @@ -2175,24 +1849,26 @@ static const yytype_int16 yytable[] = 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, 0, - 0, 421, 422, 0, 0, 0, 0, 0, 0, 0, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 423, 424, 0, 0, 0, 528, 0, 0, 0, 0, - 0, 0, 425, 426, 427, 428, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 429, 430, 431, 432, 433, 298, 0, - 0, 0, 0, 303, 304, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 434, 435, 436, 437, 438, 439, 440, - 441, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 324, 2, 3, 4, 5, + 0, 0, 293, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 294, 295, 296, 297, + 298, 0, 0, 0, 0, 0, 0, 0, 0, 299, + 300, 301, 302, 303, 304, 305, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 306, 307, + 308, 309, 310, 311, 0, 0, 0, 0, 0, 0, + 0, 0, 312, 0, 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, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 0, 0, 61, 62, 63, 64, 65, + 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, @@ -2215,24 +1891,26 @@ static const yytype_int16 yytable[] = 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, 0, 0, 421, 422, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 423, 424, 0, - 0, 584, 0, 0, 0, 0, 0, 0, 0, 425, - 426, 427, 428, 0, 0, 0, 0, 0, 0, 0, + 286, 287, 288, 289, 290, 291, 292, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 429, 430, 431, 432, 433, 298, 0, 0, 0, 0, - 303, 304, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 434, 435, 436, 437, 438, 439, 440, 441, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 387, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 324, 2, 3, 4, 5, 6, 7, 8, + 0, 0, 0, 294, 295, 296, 297, 0, 0, 0, + 0, 0, 0, 0, 0, 388, 299, 300, 301, 302, + 303, 304, 305, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 306, 307, 308, 309, 310, + 311, 0, 0, 0, 0, 0, 0, 0, 0, 312, + 0, 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, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 0, 0, 61, 62, 63, 64, 65, 66, 67, 68, + 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, @@ -2255,194 +1933,20 @@ static const yytype_int16 yytable[] = 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, 0, 0, 421, 422, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 423, 424, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 596, 425, 426, 427, 428, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 429, 430, 431, - 432, 433, 298, 0, 0, 0, 0, 303, 304, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 434, 435, 436, - 437, 438, 439, 440, 441, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 324, - 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 0, 0, 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, - 0, 0, 421, 422, 0, 0, 0, 0, 0, 0, + 289, 290, 291, 292, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 423, 424, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 425, 426, 427, 428, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 429, 430, 431, 432, 433, 298, - 0, 0, 0, 0, 303, 304, 0, 0, 0, 0, + 0, 557, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 434, 435, 436, 437, 438, 439, - 440, 441, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 324, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 0, 0, 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, 452, 0, 421, - 422, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 470, 0, 0, 0, 0, 0, 0, 423, 424, - 0, 0, 0, 0, 0, 0, 0, 0, 536, 537, - 425, 426, 427, 428, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 429, 430, 431, 432, 433, 298, 0, 0, 0, - 549, 303, 546, 0, 0, 0, 0, 0, 0, 0, - 0, 470, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 434, 435, 436, 437, 438, 439, 440, 441, 0, - 470, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 324, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 633, 0, 0, + 294, 295, 296, 297, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 299, 300, 301, 302, 303, 304, 305, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 639, 640, 641, 470, 470, 470, 470, 470, 470, 470, - 470, 470, 470, 470, 470, 470, 470, 470, 470, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 470 -}; - -static const yytype_int16 yycheck[] = -{ - 0, 323, 0, 316, 0, 318, 318, 318, 463, 0, - 318, 318, 325, 335, 326, 326, 316, 325, 325, 316, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 532, 326, 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, - 356, 348, 415, 424, 588, 526, 514, 528, 404, 320, - 531, 461, 385, 352, 298, 299, 303, 664, 391, 294, - 295, 318, 296, 297, 317, 381, 360, 326, 325, 363, - 377, 365, 366, 323, 373, 369, 326, 450, 348, 412, - 413, 352, 316, 323, 318, 692, 356, 348, 322, 396, - 334, 335, 339, 352, 364, 356, 364, 367, 364, 353, - 317, 300, 301, 364, 358, 359, 323, 377, 464, 319, - 352, 381, 703, 323, 334, 496, 377, 498, 323, 710, - 381, 326, 320, 317, 592, 323, 396, 483, 326, 323, - 721, 320, 317, 317, 317, 396, 317, 407, 323, 323, - 323, 622, 323, 459, 317, 321, 407, 323, 558, 323, - 323, 352, 326, 526, 461, 528, 463, 328, 531, 330, - 541, 320, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 545, 570, 571, 572, 573, 323, 323, 324, - 326, 725, 325, 323, 323, 352, 326, 326, 352, 459, - 318, 461, 326, 463, 675, 663, 323, 324, 459, 325, - 461, 352, 463, 341, 342, 343, 331, 332, 333, 566, - 567, 574, 575, 594, 568, 569, 626, 598, 317, 316, - 553, 352, 318, 352, 338, 532, 337, 336, 302, 304, - 319, 318, 316, 321, 715, 326, 326, 316, 316, 316, - 613, 614, 324, 326, 514, 326, 316, 316, 352, 622, - 352, 558, 317, 514, 352, 319, 319, 323, 316, 360, - 319, 321, 532, 731, 317, 316, 352, 317, 320, 325, - 317, 532, 326, 576, 320, 320, 577, 658, 326, 364, - 321, 578, 580, 664, 579, 581, 681, 381, 558, 381, - 297, 466, 552, 636, 666, 709, 721, 558, 722, 666, - 524, 377, 675, 375, 692, 524, 524, 364, 683, -1, - -1, 692, -1, -1, -1, -1, -1, -1, 588, 626, - -1, -1, 592, 704, 697, 681, -1, 588, -1, -1, - -1, 592, -1, -1, -1, -1, -1, -1, -1, 720, - -1, -1, 715, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 626, 664, -1, -1, - -1, -1, -1, -1, -1, 626, -1, -1, -1, -1, - -1, 687, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 692, -1, -1, -1, -1, - -1, -1, -1, 663, 664, -1, 666, -1, -1, -1, - -1, -1, 663, 664, -1, 666, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 687, -1, -1, - -1, -1, 692, -1, -1, -1, 687, -1, -1, -1, - -1, 692, -1, 703, -1, -1, -1, -1, -1, -1, - 710, -1, 703, -1, -1, -1, -1, -1, -1, 710, - -1, 721, -1, -1, -1, 725, -1, -1, -1, -1, - 721, 731, -1, -1, 725, -1, -1, -1, 0, -1, - 731, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 0, 0, 306, 307, 308, 309, 310, 311, 0, 0, + 0, 0, 0, 0, 0, 0, 312, 0, 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, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, @@ -2462,153 +1966,70 @@ static const yytype_int16 yycheck[] = 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, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 326, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 340, 341, - 342, 343, 344, -1, -1, -1, -1, -1, -1, -1, - -1, 353, 354, 355, 356, 357, 358, 359, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 372, 373, 374, 375, 376, 377, -1, -1, -1, -1, - -1, -1, -1, -1, 386, -1, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 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, -1, -1, - 296, 297, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 315, - 316, -1, 318, -1, 320, 321, -1, -1, -1, -1, - 326, 327, 328, 329, 330, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 340, 341, 342, 343, 344, -1, - -1, -1, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 362, 363, -1, 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, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 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, -1, -1, 296, 297, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 315, 316, -1, 318, -1, - 320, 321, -1, -1, -1, -1, 326, 327, 328, 329, - 330, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 340, 341, 342, 343, 344, -1, -1, -1, 348, 349, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 362, 363, -1, 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, 397, 398, 399, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 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, - -1, -1, 296, 297, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 315, 316, -1, 318, -1, 320, -1, -1, -1, - -1, -1, 326, 327, 328, 329, 330, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 340, 341, 342, 343, - 344, -1, -1, -1, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, - -1, 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, 397, 398, 399, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 3, 4, 5, 6, 7, + 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 639, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 294, 295, 296, + 297, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 299, 300, 301, 302, 303, 304, 305, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 306, + 307, 308, 309, 310, 311, 0, 0, 0, 0, 0, + 0, 0, 0, 312, 0, 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, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 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, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 677, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 294, 295, 296, 297, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 299, 300, 301, + 302, 303, 304, 305, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 306, 307, 308, 309, + 310, 311, 0, 0, 0, 0, 0, 0, 0, 0, + 312, 0, 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, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, @@ -2637,25 +2058,25 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 296, 297, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 315, 316, -1, - 318, -1, 320, -1, -1, -1, -1, -1, 326, 327, - 328, 329, 330, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 340, 341, 342, 343, 344, -1, -1, -1, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, -1, 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, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 288, 289, 290, 291, 292, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 295, 296, 297, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 299, 300, 301, 302, 303, 304, + 305, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 306, 307, 308, 309, 310, 311, 0, + 0, 0, 0, 0, 0, 0, 0, 312, 0, 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, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 52, 53, 54, 55, 56, 57, 58, 0, 0, 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, @@ -2679,25 +2100,63 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 296, 297, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 315, 316, -1, 318, -1, -1, -1, - -1, -1, -1, -1, 326, 327, 328, 329, 330, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 340, 341, - 342, 343, 344, -1, -1, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 362, 363, -1, 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, 397, 398, 399, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 3, 4, 5, + 292, 0, 0, 422, 423, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 424, 425, 0, 0, 0, 529, 696, 0, + 0, 0, 0, 0, 426, 427, 428, 429, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 430, 431, 432, 433, 434, + 299, 0, 0, 0, 0, 304, 305, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 435, 436, 437, 438, 439, + 440, 441, 442, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 325, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 0, 0, 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, 0, + 0, 422, 423, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 424, 425, 0, 0, 470, 0, 0, 0, 0, 0, + 0, 0, 426, 427, 428, 429, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 430, 431, 432, 433, 434, 299, 0, + 0, 0, 0, 304, 305, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 435, 436, 437, 438, 439, 440, 441, + 442, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 325, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 56, 57, 58, 0, 0, 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, @@ -2720,26 +2179,64 @@ static const yytype_int16 yycheck[] = 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, -1, -1, - 296, 297, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 315, - 316, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 326, 327, 328, 329, 330, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 340, 341, 342, 343, 344, -1, - -1, -1, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 372, 373, 374, 375, - 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, - 386, -1, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 3, 4, 5, 6, 7, 8, 9, + 286, 287, 288, 289, 290, 291, 292, 0, 0, 422, + 423, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 424, 425, + 0, 0, 0, 529, 0, 0, 0, 0, 0, 0, + 426, 427, 428, 429, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 430, 431, 432, 433, 434, 299, 0, 0, 0, + 0, 304, 305, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 435, 436, 437, 438, 439, 440, 441, 442, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 325, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 0, 0, 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, 0, 0, 422, 423, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 424, 425, 0, 0, + 585, 0, 0, 0, 0, 0, 0, 0, 426, 427, + 428, 429, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 430, + 431, 432, 433, 434, 299, 0, 0, 0, 0, 304, + 305, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 325, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 0, + 0, 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, @@ -2762,19 +2259,236 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 296, 297, -1, -1, + 290, 291, 292, 0, 0, 422, 423, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 424, 425, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 597, 426, 427, 428, 429, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 430, 431, 432, + 433, 434, 299, 0, 0, 0, 0, 304, 305, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 435, 436, 437, + 438, 439, 440, 441, 442, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 325, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 0, 0, 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, 0, 0, 422, 423, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 424, 425, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 426, 427, 428, 429, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 430, 431, 432, 433, 434, + 299, 0, 0, 0, 0, 304, 305, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 435, 436, 437, 438, 439, + 440, 441, 442, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 325, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 0, 0, 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, 453, + 0, 422, 423, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 471, 0, 0, 0, 0, 0, 0, + 424, 425, 0, 0, 0, 0, 0, 0, 0, 0, + 537, 538, 426, 427, 428, 429, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 430, 431, 432, 433, 434, 299, 0, + 0, 0, 550, 304, 547, 0, 0, 0, 0, 0, + 0, 0, 0, 471, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 435, 436, 437, 438, 439, 440, 441, + 442, 0, 471, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 325, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 634, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 640, 641, 642, 471, 471, 471, 471, 471, + 471, 471, 471, 471, 471, 471, 471, 471, 471, 471, + 471, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 471 +}; + +static const yytype_int16 yycheck[] = +{ + 0, 324, 0, 317, 0, 319, 319, 319, 464, 0, + 319, 319, 326, 336, 327, 327, 317, 326, 326, 317, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 533, 327, 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, 357, 349, 416, 425, 589, 527, 515, 529, 405, + 321, 532, 462, 386, 353, 299, 300, 304, 665, 392, + 295, 296, 319, 297, 298, 318, 382, 361, 327, 326, + 364, 378, 366, 367, 324, 374, 370, 327, 451, 349, + 413, 414, 353, 317, 324, 319, 693, 357, 349, 323, + 397, 335, 336, 340, 353, 365, 357, 365, 368, 365, + 354, 318, 301, 302, 365, 359, 360, 324, 378, 465, + 320, 353, 382, 704, 324, 335, 497, 378, 499, 324, + 711, 382, 327, 321, 318, 593, 324, 397, 484, 327, + 324, 722, 321, 318, 318, 318, 397, 318, 408, 324, + 324, 324, 623, 324, 460, 318, 322, 408, 324, 559, + 324, 324, 353, 327, 527, 462, 529, 464, 329, 532, + 331, 542, 321, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 546, 571, 572, 573, 574, 324, 324, + 325, 327, 726, 326, 324, 324, 353, 327, 327, 353, + 460, 319, 462, 327, 464, 676, 664, 324, 325, 460, + 326, 462, 353, 464, 342, 343, 344, 332, 333, 334, + 567, 568, 575, 576, 595, 569, 570, 627, 599, 318, + 317, 554, 353, 319, 353, 339, 533, 338, 337, 303, + 305, 320, 319, 317, 322, 716, 327, 327, 317, 317, + 317, 614, 615, 325, 327, 515, 327, 317, 317, 353, + 623, 353, 559, 318, 515, 353, 320, 320, 324, 317, + 361, 320, 322, 533, 732, 318, 317, 353, 318, 321, + 326, 318, 533, 327, 577, 321, 321, 578, 659, 327, + 365, 322, 579, 581, 665, 580, 582, 682, 382, 559, + 382, 298, 467, 553, 637, 667, 710, 722, 559, 723, + 667, 525, 378, 676, 376, 693, 525, 525, 365, 684, + -1, -1, 693, -1, -1, -1, -1, -1, -1, 589, + 627, -1, -1, 593, 705, 698, 682, -1, 589, -1, + -1, -1, 593, -1, -1, -1, -1, -1, -1, -1, + 721, -1, -1, 716, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 627, 665, -1, + -1, -1, -1, -1, -1, -1, 627, -1, -1, -1, + -1, -1, 688, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 693, -1, -1, -1, + -1, -1, -1, -1, 664, 665, -1, 667, -1, -1, + -1, -1, -1, 664, 665, -1, 667, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 688, -1, + -1, -1, -1, 693, -1, -1, -1, 688, -1, -1, + -1, -1, 693, -1, 704, -1, -1, -1, -1, -1, + -1, 711, -1, 704, -1, -1, -1, -1, -1, -1, + 711, -1, 722, -1, -1, -1, 726, -1, -1, -1, + -1, 722, 732, -1, -1, 726, -1, -1, -1, 0, + -1, 732, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 315, 316, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 327, 328, 329, - 330, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 340, 341, 342, 343, -1, -1, -1, -1, 348, 349, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, 382, 383, 384, 385, 386, -1, 388, 389, - 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 3, + -1, -1, -1, -1, -1, -1, 327, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 341, 342, 343, 344, 345, -1, -1, -1, -1, -1, + -1, -1, -1, 354, 355, 356, 357, 358, 359, 360, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 373, 374, 375, 376, 377, 378, -1, -1, + -1, -1, -1, -1, -1, -1, 387, -1, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, @@ -2804,144 +2518,61 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 297, 298, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 326, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 340, 341, 342, 343, - 344, -1, -1, -1, -1, -1, -1, -1, -1, 353, - 354, 355, 356, 357, 358, 359, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 372, 373, - 374, 375, 376, 377, -1, -1, -1, -1, -1, -1, - -1, -1, 386, -1, 388, 389, 390, 391, 392, 393, + -1, -1, 316, 317, -1, 319, -1, 321, 322, -1, + -1, -1, -1, 327, 328, 329, 330, 331, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 341, 342, 343, + 344, 345, -1, -1, -1, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, + 364, -1, 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, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 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, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 326, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 340, 341, 342, 343, -1, -1, -1, -1, - -1, -1, -1, -1, 352, 353, 354, 355, 356, 357, - 358, 359, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 372, 373, 374, 375, 376, 377, - -1, -1, -1, -1, -1, -1, -1, -1, 386, -1, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 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, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 321, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 340, 341, - 342, 343, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 353, 354, 355, 356, 357, 358, 359, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 372, 373, 374, 375, 376, 377, -1, -1, -1, -1, - -1, -1, -1, -1, 386, -1, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 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, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 321, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 340, 341, 342, 343, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 353, 354, 355, - 356, 357, 358, 359, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 372, 373, 374, 375, - 376, 377, -1, -1, -1, -1, -1, -1, -1, -1, - 386, -1, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 3, 4, 5, 6, 7, 8, 9, + 414, 415, 416, 417, 418, 419, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, 181, 182, 183, 184, 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, -1, -1, + 297, 298, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 316, + 317, -1, 319, -1, 321, 322, -1, -1, -1, -1, + 327, 328, 329, 330, 331, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 341, 342, 343, 344, 345, -1, + -1, -1, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 362, 363, 364, -1, 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, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, @@ -2970,67 +2601,109 @@ static const yytype_int16 yycheck[] = 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, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 321, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 340, 341, 342, 343, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 353, 354, 355, 356, 357, 358, 359, + 290, 291, 292, 293, 294, -1, -1, 297, 298, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 372, 373, 374, 375, 376, 377, -1, -1, - -1, -1, -1, -1, -1, -1, 386, -1, 388, 389, + -1, -1, -1, -1, -1, -1, 316, 317, -1, 319, + -1, 321, -1, -1, -1, -1, -1, 327, 328, 329, + 330, 331, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 341, 342, 343, 344, 345, -1, -1, -1, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 362, 363, 364, -1, 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, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 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, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 183, 184, 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, -1, -1, 297, 298, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 316, 317, -1, 319, -1, 321, -1, + -1, -1, -1, -1, 327, 328, 329, 330, 331, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 341, 342, + 343, 344, 345, -1, -1, -1, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, + 363, 364, -1, 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, 397, 398, 399, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 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, -1, + -1, 297, 298, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 340, 341, 342, 343, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 353, - 354, 355, 356, 357, 358, 359, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 372, 373, - 374, 375, 376, 377, -1, -1, -1, -1, -1, -1, - -1, -1, 386, -1, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 4, 5, 6, 7, 8, + 316, 317, -1, 319, -1, -1, -1, -1, -1, -1, + -1, 327, 328, 329, 330, 331, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 341, 342, 343, 344, 345, + -1, -1, -1, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 362, 363, 364, -1, + 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, 397, 398, 399, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 417, 418, 419, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 60, -1, -1, 63, 64, 65, 66, 67, 68, + 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, @@ -3053,24 +2726,26 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 296, 297, -1, + 289, 290, 291, 292, 293, 294, -1, -1, 297, 298, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 315, 316, -1, -1, - -1, 320, 321, -1, -1, -1, -1, -1, 327, 328, - 329, 330, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 348, - 349, 350, 351, 352, 353, -1, -1, -1, -1, 358, - 359, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 378, - 379, 380, 381, 382, 383, 384, 385, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 400, 4, 5, 6, 7, 8, 9, 10, 11, + -1, -1, -1, -1, -1, -1, -1, 316, 317, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 327, 328, + 329, 330, 331, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 341, 342, 343, 344, 345, -1, -1, -1, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 373, 374, 375, 376, 377, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, + 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, -1, - -1, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 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, @@ -3093,23 +2768,25 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 296, 297, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 315, 316, -1, -1, 319, -1, -1, - -1, -1, -1, -1, -1, 327, 328, 329, 330, -1, + 292, 293, 294, -1, -1, 297, 298, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 348, 349, 350, 351, - 352, 353, -1, -1, -1, -1, 358, 359, -1, -1, + -1, -1, -1, -1, 316, 317, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 328, 329, 330, 331, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 341, + 342, 343, 344, -1, -1, -1, -1, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 378, 379, 380, 381, - 382, 383, 384, 385, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 400, 4, + -1, 373, 374, 375, 376, 377, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, -1, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, -1, -1, 63, 64, + 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, @@ -3132,24 +2809,26 @@ static const yytype_int16 yycheck[] = 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, -1, - -1, 296, 297, -1, -1, -1, -1, -1, -1, -1, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 315, 316, -1, -1, -1, 320, -1, -1, -1, -1, - -1, -1, 327, 328, 329, 330, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 348, 349, 350, 351, 352, 353, -1, - -1, -1, -1, 358, 359, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 378, 379, 380, 381, 382, 383, 384, - 385, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 400, 4, 5, 6, 7, + -1, -1, 327, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 341, 342, 343, 344, + 345, -1, -1, -1, -1, -1, -1, -1, -1, 354, + 355, 356, 357, 358, 359, 360, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 373, 374, + 375, 376, 377, 378, -1, -1, -1, -1, -1, -1, + -1, -1, 387, -1, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, -1, -1, 63, 64, 65, 66, 67, + 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, @@ -3172,24 +2851,26 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 296, 297, + 288, 289, 290, 291, 292, 293, 294, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 315, 316, -1, - -1, 319, -1, -1, -1, -1, -1, -1, -1, 327, - 328, 329, 330, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 348, 349, 350, 351, 352, 353, -1, -1, -1, -1, - 358, 359, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 327, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 378, 379, 380, 381, 382, 383, 384, 385, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 400, 4, 5, 6, 7, 8, 9, 10, + -1, -1, -1, 341, 342, 343, 344, -1, -1, -1, + -1, -1, -1, -1, -1, 353, 354, 355, 356, 357, + 358, 359, 360, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 373, 374, 375, 376, 377, + 378, -1, -1, -1, -1, -1, -1, -1, -1, 387, + -1, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, + 418, 419, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - -1, -1, 63, 64, 65, 66, 67, 68, 69, 70, + 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, @@ -3212,23 +2893,25 @@ static const yytype_int16 yycheck[] = 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, -1, -1, 296, 297, -1, -1, -1, + 291, 292, 293, 294, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 315, 316, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 326, 327, 328, 329, 330, + -1, 322, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 348, 349, 350, - 351, 352, 353, -1, -1, -1, -1, 358, 359, -1, + 341, 342, 343, 344, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 354, 355, 356, 357, 358, 359, 360, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 378, 379, 380, - 381, 382, 383, 384, 385, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 400, + -1, -1, 373, 374, 375, 376, 377, 378, -1, -1, + -1, -1, -1, -1, -1, -1, 387, -1, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, -1, -1, 63, + 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, @@ -3252,23 +2935,25 @@ static const yytype_int16 yycheck[] = 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, - -1, -1, 296, 297, -1, -1, -1, -1, -1, -1, + 294, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 315, 316, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 327, 328, 329, 330, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 322, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 348, 349, 350, 351, 352, 353, - -1, -1, -1, -1, 358, 359, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 378, 379, 380, 381, 382, 383, - 384, 385, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 400, 4, 5, 6, + -1, -1, -1, -1, -1, -1, -1, 341, 342, 343, + 344, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 354, 355, 356, 357, 358, 359, 360, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 373, + 374, 375, 376, 377, 378, -1, -1, -1, -1, -1, + -1, -1, -1, 387, -1, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, 415, 416, 417, 418, 419, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, -1, -1, 63, 64, 65, 66, + 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, @@ -3291,26 +2976,349 @@ static const yytype_int16 yycheck[] = 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, 390, -1, 296, - 297, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 404, -1, -1, -1, -1, -1, -1, 315, 316, - -1, -1, -1, -1, -1, -1, -1, -1, 421, 422, - 327, 328, 329, 330, -1, -1, -1, -1, -1, -1, + 287, 288, 289, 290, 291, 292, 293, 294, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 322, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 341, 342, 343, 344, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 354, 355, 356, + 357, 358, 359, 360, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 373, 374, 375, 376, + 377, 378, -1, -1, -1, -1, -1, -1, -1, -1, + 387, -1, 389, 390, 391, 392, 393, 394, 395, 396, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 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, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 341, 342, 343, 344, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 354, 355, 356, 357, 358, 359, + 360, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 373, 374, 375, 376, 377, 378, -1, + -1, -1, -1, -1, -1, -1, -1, 387, -1, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, -1, -1, 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, -1, -1, 297, 298, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 316, 317, -1, -1, -1, 321, 322, -1, + -1, -1, -1, -1, 328, 329, 330, 331, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 349, 350, 351, 352, 353, + 354, -1, -1, -1, -1, 359, 360, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 379, 380, 381, 382, 383, + 384, 385, 386, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 401, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, -1, -1, 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, -1, + -1, 297, 298, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 316, 317, -1, -1, 320, -1, -1, -1, -1, -1, + -1, -1, 328, 329, 330, 331, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 349, 350, 351, 352, 353, 354, -1, + -1, -1, -1, 359, 360, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 379, 380, 381, 382, 383, 384, 385, + 386, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 401, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, -1, -1, 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, -1, -1, 297, + 298, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 316, 317, + -1, -1, -1, 321, -1, -1, -1, -1, -1, -1, + 328, 329, 330, 331, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 349, 350, 351, 352, 353, 354, -1, -1, -1, + -1, 359, 360, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 379, 380, 381, 382, 383, 384, 385, 386, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 401, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, -1, -1, 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, -1, -1, 297, 298, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 316, 317, -1, -1, + 320, -1, -1, -1, -1, -1, -1, -1, 328, 329, + 330, 331, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 349, + 350, 351, 352, 353, 354, -1, -1, -1, -1, 359, + 360, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 379, + 380, 381, 382, 383, 384, 385, 386, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 401, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, -1, + -1, 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, -1, -1, 297, 298, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 316, 317, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 327, 328, 329, 330, 331, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 349, 350, 351, + 352, 353, 354, -1, -1, -1, -1, 359, 360, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 379, 380, 381, + 382, 383, 384, 385, 386, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 401, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, -1, -1, 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, -1, -1, 297, 298, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 316, 317, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 328, 329, 330, 331, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 349, 350, 351, 352, 353, + 354, -1, -1, -1, -1, 359, 360, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 379, 380, 381, 382, 383, + 384, 385, 386, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 401, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, -1, -1, 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, 391, + -1, 297, 298, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 405, -1, -1, -1, -1, -1, -1, + 316, 317, -1, -1, -1, -1, -1, -1, -1, -1, + 422, 423, 328, 329, 330, 331, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 348, 349, 350, 351, 352, 353, -1, -1, -1, - 453, 358, 359, -1, -1, -1, -1, -1, -1, -1, - -1, 464, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 378, 379, 380, 381, 382, 383, 384, 385, -1, - 483, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 400, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 349, 350, 351, 352, 353, 354, -1, + -1, -1, 454, 359, 360, -1, -1, -1, -1, -1, + -1, -1, -1, 465, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 379, 380, 381, 382, 383, 384, 385, + 386, -1, 484, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 550, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 551, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, - 573, 574, 575, 576, 577, 578, 579, 580, 581, -1, + -1, -1, 564, 565, 566, 567, 568, 569, 570, 571, + 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, + 582, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, @@ -3320,7 +3328,7 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 681 + 682 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing @@ -3356,116 +3364,116 @@ static const yytype_uint16 yystos[] = 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, 326, 340, 341, 342, 343, 344, 353, 354, - 355, 356, 357, 358, 359, 372, 373, 374, 375, 376, - 377, 386, 388, 389, 390, 391, 392, 393, 394, 395, + 292, 293, 294, 327, 341, 342, 343, 344, 345, 354, + 355, 356, 357, 358, 359, 360, 373, 374, 375, 376, + 377, 378, 387, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 450, 451, 454, 455, 456, 457, 461, - 462, 463, 464, 465, 466, 469, 470, 471, 472, 473, - 475, 480, 481, 482, 523, 524, 525, 481, 320, 352, - 316, 316, 326, 352, 326, 526, 317, 323, 458, 459, - 460, 470, 475, 323, 326, 352, 326, 352, 471, 475, - 334, 477, 478, 0, 524, 475, 484, 320, 352, 373, - 467, 468, 352, 474, 318, 326, 476, 320, 502, 459, - 458, 460, 352, 352, 316, 325, 476, 320, 323, 326, - 453, 296, 297, 315, 316, 327, 328, 329, 330, 348, - 349, 350, 351, 352, 378, 379, 380, 381, 382, 383, - 384, 385, 420, 421, 422, 424, 425, 426, 427, 428, - 429, 430, 431, 432, 473, 475, 479, 476, 326, 470, - 475, 485, 486, 483, 325, 317, 323, 317, 323, 319, - 431, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 318, 326, 318, 320, 321, 326, 360, - 361, 362, 363, 365, 366, 367, 368, 369, 370, 371, - 387, 431, 444, 446, 448, 450, 454, 473, 475, 491, - 492, 493, 494, 495, 503, 504, 505, 506, 509, 510, - 513, 514, 515, 522, 527, 476, 325, 476, 320, 446, - 489, 325, 452, 352, 323, 326, 431, 431, 448, 296, - 297, 318, 322, 317, 317, 323, 359, 446, 316, 431, - 323, 335, 475, 352, 487, 488, 321, 486, 485, 444, - 449, 468, 352, 331, 332, 333, 328, 330, 294, 295, - 298, 299, 334, 335, 300, 301, 338, 337, 336, 302, - 304, 303, 339, 319, 319, 444, 318, 321, 496, 316, - 326, 326, 517, 316, 316, 326, 326, 448, 316, 448, - 324, 326, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 325, 447, 323, 326, 321, 492, 506, 510, - 515, 489, 325, 489, 490, 489, 485, 352, 317, 423, - 448, 352, 446, 431, 487, 476, 323, 326, 321, 431, - 431, 431, 433, 433, 434, 434, 435, 435, 435, 435, - 436, 436, 437, 438, 439, 440, 441, 442, 445, 319, - 352, 528, 529, 503, 516, 492, 518, 448, 326, 448, - 324, 446, 446, 489, 321, 323, 321, 319, 326, 488, - 448, 316, 319, 323, 497, 448, 463, 470, 508, 360, - 491, 504, 519, 317, 317, 321, 489, 324, 449, 319, - 529, 321, 352, 317, 316, 508, 520, 521, 499, 500, - 501, 507, 511, 446, 317, 325, 493, 498, 502, 448, - 326, 317, 364, 495, 493, 320, 489, 317, 448, 498, - 499, 503, 512, 326, 321 + 416, 417, 418, 419, 451, 452, 455, 456, 457, 458, + 462, 463, 464, 465, 466, 467, 470, 471, 472, 473, + 474, 476, 481, 482, 483, 524, 525, 526, 482, 321, + 353, 317, 317, 327, 353, 327, 527, 318, 324, 459, + 460, 461, 471, 476, 324, 327, 353, 327, 353, 472, + 476, 335, 478, 479, 0, 525, 476, 485, 321, 353, + 374, 468, 469, 353, 475, 319, 327, 477, 321, 503, + 460, 459, 461, 353, 353, 317, 326, 477, 321, 324, + 327, 454, 297, 298, 316, 317, 328, 329, 330, 331, + 349, 350, 351, 352, 353, 379, 380, 381, 382, 383, + 384, 385, 386, 421, 422, 423, 425, 426, 427, 428, + 429, 430, 431, 432, 433, 474, 476, 480, 477, 327, + 471, 476, 486, 487, 484, 326, 318, 324, 318, 324, + 320, 432, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 319, 327, 319, 321, 322, 327, + 361, 362, 363, 364, 366, 367, 368, 369, 370, 371, + 372, 388, 432, 445, 447, 449, 451, 455, 474, 476, + 492, 493, 494, 495, 496, 504, 505, 506, 507, 510, + 511, 514, 515, 516, 523, 528, 477, 326, 477, 321, + 447, 490, 326, 453, 353, 324, 327, 432, 432, 449, + 297, 298, 319, 323, 318, 318, 324, 360, 447, 317, + 432, 324, 336, 476, 353, 488, 489, 322, 487, 486, + 445, 450, 469, 353, 332, 333, 334, 329, 331, 295, + 296, 299, 300, 335, 336, 301, 302, 339, 338, 337, + 303, 305, 304, 340, 320, 320, 445, 319, 322, 497, + 317, 327, 327, 518, 317, 317, 327, 327, 449, 317, + 449, 325, 327, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 326, 448, 324, 327, 322, 493, 507, + 511, 516, 490, 326, 490, 491, 490, 486, 353, 318, + 424, 449, 353, 447, 432, 488, 477, 324, 327, 322, + 432, 432, 432, 434, 434, 435, 435, 436, 436, 436, + 436, 437, 437, 438, 439, 440, 441, 442, 443, 446, + 320, 353, 529, 530, 504, 517, 493, 519, 449, 327, + 449, 325, 447, 447, 490, 322, 324, 322, 320, 327, + 489, 449, 317, 320, 324, 498, 449, 464, 471, 509, + 361, 492, 505, 520, 318, 318, 322, 490, 325, 450, + 320, 530, 322, 353, 318, 317, 509, 521, 522, 500, + 501, 502, 508, 512, 447, 318, 326, 494, 499, 503, + 449, 327, 318, 365, 496, 494, 321, 490, 318, 449, + 499, 500, 504, 513, 327, 322 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint16 yyr1[] = { - 0, 419, 420, 421, 421, 421, 421, 421, 421, 421, - 421, 421, 421, 421, 421, 421, 421, 421, 422, 422, - 422, 422, 422, 422, 423, 424, 425, 426, 426, 427, - 427, 428, 428, 429, 430, 430, 430, 431, 431, 431, - 431, 432, 432, 432, 432, 433, 433, 433, 433, 434, - 434, 434, 435, 435, 435, 436, 436, 436, 436, 436, - 437, 437, 437, 438, 438, 439, 439, 440, 440, 441, - 441, 442, 442, 443, 443, 444, 445, 444, 446, 446, - 447, 447, 447, 447, 447, 447, 447, 447, 447, 447, - 447, 448, 448, 449, 450, 450, 450, 450, 450, 450, - 450, 450, 450, 452, 451, 453, 453, 454, 455, 455, - 456, 456, 457, 458, 458, 459, 459, 459, 459, 460, - 461, 461, 461, 461, 461, 462, 462, 462, 462, 462, - 463, 463, 464, 465, 465, 465, 465, 465, 465, 465, - 465, 466, 467, 467, 468, 468, 468, 469, 470, 470, - 471, 471, 471, 471, 471, 471, 471, 472, 472, 472, - 472, 472, 472, 472, 472, 472, 472, 472, 472, 472, - 472, 472, 472, 472, 472, 472, 472, 472, 472, 472, - 472, 472, 472, 472, 472, 472, 472, 472, 472, 472, - 472, 472, 473, 474, 474, 475, 475, 476, 476, 476, - 476, 477, 477, 478, 479, 479, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 480, 480, 481, 481, 481, - 483, 482, 484, 482, 485, 485, 486, 486, 487, 487, - 488, 488, 489, 489, 489, 490, 490, 491, 492, 492, - 493, 493, 493, 493, 493, 493, 493, 493, 494, 495, - 496, 497, 495, 498, 498, 500, 499, 501, 499, 502, - 502, 503, 503, 504, 504, 505, 505, 506, 507, 507, - 508, 508, 509, 509, 511, 510, 512, 512, 513, 513, - 514, 514, 516, 515, 517, 515, 518, 515, 519, 519, - 520, 520, 521, 521, 522, 522, 522, 522, 522, 523, - 523, 524, 524, 524, 526, 525, 527, 528, 528, 529, - 529 + 0, 420, 421, 422, 422, 422, 422, 422, 422, 422, + 422, 422, 422, 422, 422, 422, 422, 422, 423, 423, + 423, 423, 423, 423, 424, 425, 426, 427, 427, 428, + 428, 429, 429, 430, 431, 431, 431, 432, 432, 432, + 432, 433, 433, 433, 433, 434, 434, 434, 434, 435, + 435, 435, 436, 436, 436, 437, 437, 437, 437, 437, + 438, 438, 438, 439, 439, 440, 440, 441, 441, 442, + 442, 443, 443, 444, 444, 445, 446, 445, 447, 447, + 448, 448, 448, 448, 448, 448, 448, 448, 448, 448, + 448, 449, 449, 450, 451, 451, 451, 451, 451, 451, + 451, 451, 451, 453, 452, 454, 454, 455, 456, 456, + 457, 457, 458, 459, 459, 460, 460, 460, 460, 461, + 462, 462, 462, 462, 462, 463, 463, 463, 463, 463, + 464, 464, 465, 466, 466, 466, 466, 466, 466, 466, + 466, 467, 468, 468, 469, 469, 469, 470, 471, 471, + 472, 472, 472, 472, 472, 472, 472, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, + 473, 473, 474, 475, 475, 476, 476, 477, 477, 477, + 477, 478, 478, 479, 480, 480, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, + 481, 481, 481, 481, 481, 481, 481, 481, 482, 482, + 482, 484, 483, 485, 483, 486, 486, 487, 487, 488, + 488, 489, 489, 490, 490, 490, 491, 491, 492, 493, + 493, 494, 494, 494, 494, 494, 494, 494, 494, 495, + 496, 497, 498, 496, 499, 499, 501, 500, 502, 500, + 503, 503, 504, 504, 505, 505, 506, 506, 507, 508, + 508, 509, 509, 510, 510, 512, 511, 513, 513, 514, + 514, 515, 515, 517, 516, 518, 516, 519, 516, 520, + 520, 521, 521, 522, 522, 523, 523, 523, 523, 523, + 524, 524, 525, 525, 525, 527, 526, 528, 529, 529, + 530, 530 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ @@ -3521,16 +3529,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, - 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, 1, 2, 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, 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, 1, 2, + 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 }; @@ -4213,260 +4221,260 @@ yyreduce: switch (yyn) { case 2: -#line 355 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 357 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string); } -#line 4221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4229 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 3: -#line 361 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 363 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4229 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4237 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 4: -#line 364 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 366 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); if ((yyval.interm.intermTypedNode)->getAsConstantUnion()) (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } -#line 4239 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4247 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 5: -#line 369 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 371 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 4247 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4255 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 6: -#line 372 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 374 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 4255 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4263 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 7: -#line 375 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 377 "glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 4264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4272 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 8: -#line 379 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 381 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 4272 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4280 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 9: -#line 383 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 385 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true); } -#line 4280 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4288 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 10: -#line 386 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 388 "glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 4289 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4297 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 11: -#line 390 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 392 "glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 4298 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4306 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 12: -#line 394 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 396 "glslang.y" /* yacc.c:1646 */ { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true); } -#line 4307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4315 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 13: -#line 398 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 400 "glslang.y" /* yacc.c:1646 */ { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true); } -#line 4316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4324 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 14: -#line 402 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 404 "glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 4325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4333 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 15: -#line 406 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 408 "glslang.y" /* yacc.c:1646 */ { parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 4334 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4342 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 16: -#line 410 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 412 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double literal"); if (! parseContext.symbolTable.atBuiltInLevel()) 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 4345 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4353 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 17: -#line 416 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 418 "glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true); } -#line 4354 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4362 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 18: -#line 424 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 426 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4362 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4370 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 19: -#line 427 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 429 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode)); } -#line 4370 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4378 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 20: -#line 430 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 432 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4378 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4386 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 21: -#line 433 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 435 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string); } -#line 4386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4394 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 22: -#line 436 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 438 "glslang.y" /* yacc.c:1646 */ { parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode)); } -#line 4396 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4404 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 23: -#line 441 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 443 "glslang.y" /* yacc.c:1646 */ { parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode)); } -#line 4406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4414 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 24: -#line 449 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 451 "glslang.y" /* yacc.c:1646 */ { parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]"); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4415 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4423 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 25: -#line 456 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 458 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode); delete (yyvsp[0].interm).function; } -#line 4424 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4432 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 26: -#line 463 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 465 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); } -#line 4432 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4440 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 27: -#line 469 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 471 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-1].interm); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 4441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4449 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 28: -#line 473 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 475 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-1].interm); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 4450 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4458 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 29: -#line 480 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 482 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-1].interm); } -#line 4458 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4466 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 30: -#line 483 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 485 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); } -#line 4466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4474 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 31: -#line 489 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 491 "glslang.y" /* yacc.c:1646 */ { TParameter param = { 0, new TType }; param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType()); @@ -4474,11 +4482,11 @@ yyreduce: (yyval.interm).function = (yyvsp[-1].interm).function; (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode); } -#line 4478 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4486 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 32: -#line 496 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 498 "glslang.y" /* yacc.c:1646 */ { TParameter param = { 0, new TType }; param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType()); @@ -4486,29 +4494,29 @@ yyreduce: (yyval.interm).function = (yyvsp[-2].interm).function; (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); } -#line 4490 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4498 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 33: -#line 506 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 508 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-1].interm); } -#line 4498 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4506 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 34: -#line 514 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 516 "glslang.y" /* yacc.c:1646 */ { // Constructor (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 4508 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4516 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 35: -#line 519 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 521 "glslang.y" /* yacc.c:1646 */ { // // Should be a method or subroutine call, but we haven't recognized the arguments yet. @@ -4536,50 +4544,50 @@ yyreduce: (yyval.interm).function = new TFunction(empty, TType(EbtVoid), EOpNull); } } -#line 4540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4548 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 36: -#line 547 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 549 "glslang.y" /* yacc.c:1646 */ { // Constructor (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 4550 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4558 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 37: -#line 556 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 558 "glslang.y" /* yacc.c:1646 */ { parseContext.variableCheck((yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode()) parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), ""); } -#line 4561 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4569 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 38: -#line 562 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 564 "glslang.y" /* yacc.c:1646 */ { parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode)); } -#line 4570 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4578 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 39: -#line 566 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 568 "glslang.y" /* yacc.c:1646 */ { parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode)); } -#line 4579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4587 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 40: -#line 570 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 572 "glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-1].interm).op != EOpNull) { char errorOp[2] = {0, 0}; @@ -4596,179 +4604,179 @@ yyreduce: (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } } -#line 4600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4608 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 41: -#line 590 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 592 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; } -#line 4606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4614 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 42: -#line 591 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 593 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; } -#line 4612 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4620 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 43: -#line 592 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 594 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; } -#line 4618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4626 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 44: -#line 593 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 595 "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 4625 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4633 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 45: -#line 599 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 601 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4639 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 46: -#line 600 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 602 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "*", EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4641 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4649 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 47: -#line 605 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 607 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "/", EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4651 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4659 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 48: -#line 610 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 612 "glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "%"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "%", EOpMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4662 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4670 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 49: -#line 619 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 621 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4676 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 50: -#line 620 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 622 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "+", EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4686 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 51: -#line 625 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 627 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "-", EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4688 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4696 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 52: -#line 633 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 635 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4694 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4702 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 53: -#line 634 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 636 "glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift left"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<<", EOpLeftShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4705 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4713 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 54: -#line 640 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 642 "glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift right"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">>", EOpRightShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4716 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4724 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 55: -#line 649 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 651 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4722 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4730 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 56: -#line 650 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 652 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<", EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4740 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 57: -#line 655 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 657 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">", EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4750 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 58: -#line 660 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 662 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<=", EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4752 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4760 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 59: -#line 665 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 667 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4770 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 60: -#line 673 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 675 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4768 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4776 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 61: -#line 674 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 676 "glslang.y" /* yacc.c:1646 */ { parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=="); @@ -4778,11 +4786,11 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4790 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 62: -#line 683 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 685 "glslang.y" /* yacc.c:1646 */ { parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!="); @@ -4792,124 +4800,124 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4796 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4804 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 63: -#line 695 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 697 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4802 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4810 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 64: -#line 696 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 698 "glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise and"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&", EOpAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4813 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4821 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 65: -#line 705 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 707 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4819 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4827 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 66: -#line 706 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 708 "glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise exclusive or"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^", EOpExclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4830 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4838 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 67: -#line 715 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 717 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4836 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4844 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 68: -#line 716 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 718 "glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise inclusive or"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "|", EOpInclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 4847 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4855 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 69: -#line 725 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 727 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4861 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 70: -#line 726 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 728 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&&", EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4871 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 71: -#line 734 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 736 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4869 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4877 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 72: -#line 735 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 737 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^^", EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4879 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4887 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 73: -#line 743 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 745 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4893 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 74: -#line 744 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 746 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "||", EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 4895 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4903 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 75: -#line 752 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 754 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4901 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4909 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 76: -#line 753 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 755 "glslang.y" /* yacc.c:1646 */ { ++parseContext.controlFlowNestingLevel; } -#line 4909 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4917 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 77: -#line 756 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 758 "glslang.y" /* yacc.c:1646 */ { --parseContext.controlFlowNestingLevel; parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode)); @@ -4922,17 +4930,17 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 4926 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4934 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 78: -#line 771 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 773 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 4932 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4940 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 79: -#line 772 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 774 "glslang.y" /* yacc.c:1646 */ { parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment"); parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "="); @@ -4946,119 +4954,119 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } } -#line 4950 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4958 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 80: -#line 788 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 790 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAssign; } -#line 4959 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4967 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 81: -#line 792 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 794 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpMulAssign; } -#line 4968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4976 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 82: -#line 796 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 798 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpDivAssign; } -#line 4977 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4985 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 83: -#line 800 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 802 "glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%="); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpModAssign; } -#line 4987 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 4995 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 84: -#line 805 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 807 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAddAssign; } -#line 4996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5004 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 85: -#line 809 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 811 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpSubAssign; } -#line 5005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5013 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 86: -#line 813 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 815 "glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign; } -#line 5014 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5022 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 87: -#line 817 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 819 "glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign; } -#line 5023 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5031 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 88: -#line 821 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 823 "glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign; } -#line 5032 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5040 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 89: -#line 825 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 827 "glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign; } -#line 5041 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5049 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 90: -#line 829 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 831 "glslang.y" /* yacc.c:1646 */ { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign; } -#line 5050 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5058 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 91: -#line 836 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 838 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5058 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5066 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 92: -#line 839 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 841 "glslang.y" /* yacc.c:1646 */ { parseContext.samplerConstructorLocationCheck((yyvsp[-1].lex).loc, ",", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); @@ -5067,40 +5075,40 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 5071 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5079 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 93: -#line 850 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 852 "glslang.y" /* yacc.c:1646 */ { parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), ""); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5080 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5088 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 94: -#line 857 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 859 "glslang.y" /* yacc.c:1646 */ { parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */); (yyval.interm.intermNode) = 0; // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature } -#line 5090 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5098 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 95: -#line 862 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 864 "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 5100 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5108 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 96: -#line 867 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 869 "glslang.y" /* yacc.c:1646 */ { parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement"); // lazy setting of the previous scope's defaults, has effect only the first time it is called in a particular scope @@ -5108,75 +5116,75 @@ yyreduce: parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision); (yyval.interm.intermNode) = 0; } -#line 5112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5120 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 97: -#line 874 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 876 "glslang.y" /* yacc.c:1646 */ { parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList); (yyval.interm.intermNode) = 0; } -#line 5121 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5129 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 98: -#line 878 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 880 "glslang.y" /* yacc.c:1646 */ { parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string); (yyval.interm.intermNode) = 0; } -#line 5130 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5138 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 99: -#line 882 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 884 "glslang.y" /* yacc.c:1646 */ { parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes); (yyval.interm.intermNode) = 0; } -#line 5139 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5147 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 100: -#line 886 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 888 "glslang.y" /* yacc.c:1646 */ { parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier); parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type)); (yyval.interm.intermNode) = 0; } -#line 5149 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5157 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 101: -#line 891 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 893 "glslang.y" /* yacc.c:1646 */ { parseContext.checkNoShaderLayouts((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).shaderQualifiers); parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].lex).string); (yyval.interm.intermNode) = 0; } -#line 5159 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5167 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 102: -#line 896 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 898 "glslang.y" /* yacc.c:1646 */ { parseContext.checkNoShaderLayouts((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).shaderQualifiers); (yyvsp[-1].interm.identifierList)->push_back((yyvsp[-2].lex).string); parseContext.addQualifierToExisting((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier, *(yyvsp[-1].interm.identifierList)); (yyval.interm.intermNode) = 0; } -#line 5170 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5178 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 103: -#line 905 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 907 "glslang.y" /* yacc.c:1646 */ { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); } -#line 5176 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5184 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 104: -#line 905 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 907 "glslang.y" /* yacc.c:1646 */ { --parseContext.structNestingLevel; parseContext.blockName = (yyvsp[-4].lex).string; @@ -5186,54 +5194,54 @@ yyreduce: (yyval.interm).loc = (yyvsp[-5].interm.type).loc; (yyval.interm).typeList = (yyvsp[-1].interm.typeList); } -#line 5190 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5198 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 105: -#line 916 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 918 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.identifierList) = new TIdentifierList; (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 5199 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5207 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 106: -#line 920 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 922 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList); (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 5208 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5216 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 107: -#line 927 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 929 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).function = (yyvsp[-1].interm.function); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 5217 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5225 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 108: -#line 934 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 936 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 5225 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5233 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 109: -#line 937 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 939 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 5233 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5241 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 110: -#line 944 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 946 "glslang.y" /* yacc.c:1646 */ { // Add the parameter (yyval.interm.function) = (yyvsp[-1].interm.function); @@ -5242,11 +5250,11 @@ yyreduce: else delete (yyvsp[0].interm).param.type; } -#line 5246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5254 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 111: -#line 952 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 954 "glslang.y" /* yacc.c:1646 */ { // // Only first parameter of one-parameter functions can be void @@ -5264,11 +5272,11 @@ yyreduce: (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param); } } -#line 5268 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5276 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 112: -#line 972 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 974 "glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-2].interm.type).qualifier.storage != EvqGlobal && (yyvsp[-2].interm.type).qualifier.storage != EvqTemporary) { parseContext.error((yyvsp[-1].lex).loc, "no qualifiers allowed for function return", @@ -5288,11 +5296,11 @@ yyreduce: function = new TFunction((yyvsp[-1].lex).string, type); (yyval.interm.function) = function; } -#line 5292 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5300 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 113: -#line 995 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 997 "glslang.y" /* yacc.c:1646 */ { if ((yyvsp[-1].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -5308,11 +5316,11 @@ yyreduce: (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).param = param; } -#line 5312 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5320 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 114: -#line 1010 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1012 "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"); @@ -5332,11 +5340,11 @@ yyreduce: (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).param = param; } -#line 5336 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5344 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 115: -#line 1035 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1037 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) @@ -5348,11 +5356,11 @@ yyreduce: parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); } -#line 5352 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5360 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 116: -#line 1046 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1048 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); @@ -5360,11 +5368,11 @@ yyreduce: parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier()); } -#line 5364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5372 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 117: -#line 1056 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1058 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) @@ -5375,11 +5383,11 @@ yyreduce: parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type); parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); } -#line 5379 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5387 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 118: -#line 1066 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1068 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); @@ -5387,68 +5395,68 @@ 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 5391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5399 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 119: -#line 1076 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1078 "glslang.y" /* yacc.c:1646 */ { TParameter param = { 0, new TType((yyvsp[0].interm.type)) }; (yyval.interm).param = param; if ((yyvsp[0].interm.type).arraySizes) parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes); } -#line 5402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5410 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 120: -#line 1085 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1087 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[0].interm); } -#line 5410 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5418 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 121: -#line 1088 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1090 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-2].interm); parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type); } -#line 5419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5427 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 122: -#line 1092 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1094 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-3].interm); parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes); } -#line 5428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5436 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 123: -#line 1096 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1098 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[-5].interm).type; TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-5].interm).type, (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-5].interm).intermNode, initNode, (yyvsp[-1].lex).loc); } -#line 5438 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5446 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 124: -#line 1101 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1103 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[-4].interm).type; TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-4].interm).type, 0, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-4].interm).intermNode, initNode, (yyvsp[-1].lex).loc); } -#line 5448 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5456 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 125: -#line 1109 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1111 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[0].interm.type); (yyval.interm).intermNode = 0; @@ -5456,51 +5464,51 @@ yyreduce: parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type); } -#line 5460 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5468 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 126: -#line 1116 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1118 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[-1].interm.type); (yyval.interm).intermNode = 0; parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type)); } -#line 5470 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5478 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 127: -#line 1121 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1123 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[-2].interm.type); (yyval.interm).intermNode = 0; parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes); } -#line 5480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5488 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 128: -#line 1126 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1128 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[-4].interm.type); TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-4].interm.type), (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); } -#line 5490 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5498 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 129: -#line 1131 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1133 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).type = (yyvsp[-3].interm.type); TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); } -#line 5500 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5508 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 130: -#line 1140 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1142 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); @@ -5511,11 +5519,11 @@ yyreduce: } parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier); } -#line 5515 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5523 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 131: -#line 1150 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1152 "glslang.y" /* yacc.c:1646 */ { parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier); parseContext.globalQualifierTypeCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, (yyvsp[0].interm.type)); @@ -5540,22 +5548,22 @@ yyreduce: (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn))) (yyval.interm.type).qualifier.smooth = true; } -#line 5544 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5552 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 132: -#line 1177 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1179 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "invariant"); parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.invariant = true; } -#line 5555 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5563 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 133: -#line 1186 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1188 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "smooth"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth"); @@ -5563,11 +5571,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.smooth = true; } -#line 5567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5575 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 134: -#line 1193 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1195 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "flat"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat"); @@ -5575,11 +5583,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.flat = true; } -#line 5579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5587 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 135: -#line 1201 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1203 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_shader_noperspective_interpolation, "noperspective"); @@ -5587,11 +5595,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nopersp = true; } -#line 5591 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5599 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 136: -#line 1208 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1210 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation"); @@ -5599,11 +5607,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.explicitInterp = true; } -#line 5603 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5611 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 137: -#line 1215 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1217 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexNV"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric"); @@ -5612,11 +5620,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.pervertexNV = true; } -#line 5616 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5624 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 138: -#line 1223 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1225 "glslang.y" /* yacc.c:1646 */ { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveNV"); @@ -5627,11 +5635,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perPrimitiveNV = true; } -#line 5631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5639 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 139: -#line 1233 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1235 "glslang.y" /* yacc.c:1646 */ { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perviewNV"); @@ -5639,11 +5647,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perViewNV = true; } -#line 5643 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5651 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 140: -#line 1240 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1242 "glslang.y" /* yacc.c:1646 */ { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "taskNV"); @@ -5651,84 +5659,84 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perTaskNV = true; } -#line 5655 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5663 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 141: -#line 1251 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1253 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[-1].interm.type); } -#line 5663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5671 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 142: -#line 1257 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1259 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5679 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 143: -#line 1260 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1262 "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 5681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5689 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 144: -#line 1267 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1269 "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 5690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5698 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 145: -#line 1271 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1273 "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 5699 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5707 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 146: -#line 1275 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1277 "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 5709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5717 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 147: -#line 1284 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1286 "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 5720 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5728 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 148: -#line 1294 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1296 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5728 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5736 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 149: -#line 1297 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1299 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[-1].interm.type); if ((yyval.interm.type).basicType == EbtVoid) @@ -5737,112 +5745,112 @@ 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 5741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5749 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 150: -#line 1308 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1310 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5749 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5757 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 151: -#line 1311 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1313 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5757 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5765 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 152: -#line 1314 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1316 "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 5766 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5774 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 153: -#line 1318 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1320 "glslang.y" /* yacc.c:1646 */ { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5775 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5783 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 154: -#line 1322 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1324 "glslang.y" /* yacc.c:1646 */ { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5784 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5792 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 155: -#line 1327 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1329 "glslang.y" /* yacc.c:1646 */ { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5793 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5801 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 156: -#line 1331 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1333 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 5801 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5809 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 157: -#line 1338 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1340 "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 5810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5818 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 158: -#line 1342 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1344 "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 5820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5828 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 159: -#line 1347 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1349 "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 5831 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5839 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 160: -#line 1353 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1355 "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 5842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5850 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 161: -#line 1359 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1361 "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"); @@ -5850,21 +5858,21 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.centroid = true; } -#line 5854 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5862 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 162: -#line 1366 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1368 "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 5864 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5872 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 163: -#line 1371 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1373 "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"); @@ -5873,21 +5881,21 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqShared; } -#line 5877 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5885 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 164: -#line 1379 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1381 "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 5887 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5895 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 165: -#line 1385 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1387 "glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute"); @@ -5900,11 +5908,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 5904 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5912 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 166: -#line 1397 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1399 "glslang.y" /* yacc.c:1646 */ { parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying"); @@ -5919,32 +5927,32 @@ yyreduce: else (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 5923 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5931 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 167: -#line 1411 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1413 "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 5934 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5942 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 168: -#line 1417 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1419 "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 5944 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5952 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 169: -#line 1422 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1424 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask @@ -5953,11 +5961,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitAttr; } -#line 5957 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5965 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 170: -#line 1430 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1432 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask @@ -5966,11 +5974,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitAttr; } -#line 5970 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5978 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 171: -#line 1438 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1440 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask | @@ -5979,11 +5987,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayload; } -#line 5983 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 5991 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 172: -#line 1446 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1448 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask | @@ -5992,11 +6000,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayload; } -#line 5996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6004 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 173: -#line 1454 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1456 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask | @@ -6005,11 +6013,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayloadIn; } -#line 6009 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6017 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 174: -#line 1462 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1464 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask | @@ -6018,11 +6026,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayloadIn; } -#line 6022 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6030 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 175: -#line 1470 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1472 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | @@ -6031,11 +6039,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableData; } -#line 6035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6043 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 176: -#line 1478 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1480 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | @@ -6044,11 +6052,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableData; } -#line 6048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6056 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 177: -#line 1486 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1488 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInNV"); @@ -6056,11 +6064,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableDataIn; } -#line 6060 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6068 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 178: -#line 1493 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1495 "glslang.y" /* yacc.c:1646 */ { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInEXT"); @@ -6068,175 +6076,175 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableDataIn; } -#line 6072 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6080 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 179: -#line 1500 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1502 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.coherent = true; } -#line 6081 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6089 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 180: -#line 1504 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1506 "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 6091 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6099 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 181: -#line 1509 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1511 "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 6101 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6109 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 182: -#line 1514 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1516 "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 6111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6119 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 183: -#line 1519 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1521 "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 6121 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6129 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 184: -#line 1524 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1526 "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 6131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6139 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 185: -#line 1529 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1531 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_ray_tracing, "shadercallcoherent"); (yyval.interm.type).qualifier.shadercallcoherent = true; } -#line 6141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6149 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 186: -#line 1534 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1536 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.volatil = true; } -#line 6150 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6158 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 187: -#line 1538 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1540 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.restrict = true; } -#line 6159 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6167 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 188: -#line 1542 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1544 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.readonly = true; } -#line 6168 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6176 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 189: -#line 1546 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1548 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.writeonly = true; } -#line 6177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6185 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 190: -#line 1550 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1552 "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 6188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6196 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 191: -#line 1556 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1558 "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 6199 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6207 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 192: -#line 1567 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1569 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nonUniform = true; } -#line 6208 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6216 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 193: -#line 1574 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1576 "glslang.y" /* yacc.c:1646 */ { // TODO } -#line 6216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6224 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 194: -#line 1577 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1579 "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 6226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6234 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 195: -#line 1586 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1588 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type) = (yyvsp[-1].interm.type); (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); (yyval.interm.type).typeParameters = (yyvsp[0].interm.typeParameters); } -#line 6236 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6244 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 196: -#line 1591 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1593 "glslang.y" /* yacc.c:1646 */ { parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes); (yyval.interm.type) = (yyvsp[-2].interm.type); @@ -6244,21 +6252,21 @@ yyreduce: (yyval.interm.type).typeParameters = (yyvsp[-1].interm.typeParameters); (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes; } -#line 6248 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6256 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 197: -#line 1601 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1603 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).arraySizes = new TArraySizes; (yyval.interm).arraySizes->addInnerSize(); } -#line 6258 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6266 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 198: -#line 1606 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1608 "glslang.y" /* yacc.c:1646 */ { (yyval.interm).loc = (yyvsp[-2].lex).loc; (yyval.interm).arraySizes = new TArraySizes; @@ -6267,20 +6275,20 @@ yyreduce: parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size"); (yyval.interm).arraySizes->addInnerSize(size); } -#line 6271 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6279 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 199: -#line 1614 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1616 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-2].interm); (yyval.interm).arraySizes->addInnerSize(); } -#line 6280 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6288 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 200: -#line 1618 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1620 "glslang.y" /* yacc.c:1646 */ { (yyval.interm) = (yyvsp[-3].interm); @@ -6288,35 +6296,35 @@ yyreduce: parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size"); (yyval.interm).arraySizes->addInnerSize(size); } -#line 6292 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6300 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 201: -#line 1628 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1630 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeParameters) = (yyvsp[0].interm.typeParameters); } -#line 6300 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6308 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 202: -#line 1631 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1633 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeParameters) = 0; } -#line 6308 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6316 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 203: -#line 1637 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1639 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeParameters) = (yyvsp[-1].interm.typeParameters); } -#line 6316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6324 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 204: -#line 1643 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1645 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeParameters) = new TArraySizes; @@ -6324,11 +6332,11 @@ yyreduce: parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter"); (yyval.interm.typeParameters)->addInnerSize(size); } -#line 6328 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6336 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 205: -#line 1650 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1652 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeParameters) = (yyvsp[-2].interm.typeParameters); @@ -6336,300 +6344,300 @@ yyreduce: parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter"); (yyval.interm.typeParameters)->addInnerSize(size); } -#line 6340 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6348 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 206: -#line 1660 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1662 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtVoid; } -#line 6349 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6357 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 207: -#line 1664 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1666 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } -#line 6358 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6366 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 208: -#line 1668 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1670 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } -#line 6367 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6375 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 209: -#line 1672 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1674 "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 6377 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6385 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 210: -#line 1677 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1679 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; } -#line 6386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6394 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 211: -#line 1681 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1683 "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 6396 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6404 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 212: -#line 1686 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1688 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(3); } -#line 6406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6414 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 213: -#line 1691 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1693 "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 6416 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6424 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 214: -#line 1696 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1698 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(2); } -#line 6426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6434 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 215: -#line 1701 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1703 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(3); } -#line 6436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6444 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 216: -#line 1706 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1708 "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 6446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6454 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 217: -#line 1711 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1713 "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 6456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6464 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 218: -#line 1716 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1718 "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 6466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6474 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 219: -#line 1721 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1723 "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 6476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6484 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 220: -#line 1726 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1728 "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 6487 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6495 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 221: -#line 1732 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1734 "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 6498 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6506 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 222: -#line 1738 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1740 "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 6509 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6517 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 223: -#line 1744 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1746 "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 6519 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6527 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 224: -#line 1749 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1751 "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 6529 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6537 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 225: -#line 1754 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1756 "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 6539 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6547 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 226: -#line 1759 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1761 "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 6549 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6557 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 227: -#line 1764 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1766 "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 6559 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6567 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 228: -#line 1769 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1771 "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 6569 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6577 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 229: -#line 1774 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1776 "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 6579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6587 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 230: -#line 1779 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1781 "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 6589 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6597 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 231: -#line 1784 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1786 "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 6599 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6607 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 232: -#line 1789 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1791 "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 6609 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6617 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 233: -#line 1794 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1796 "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 6619 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6627 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 234: -#line 1799 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1801 "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 6629 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6637 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 235: -#line 1805 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1807 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -6637,121 +6645,121 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; } -#line 6641 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6649 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 236: -#line 1812 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1814 "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 6651 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6659 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 237: -#line 1817 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1819 "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 6661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6669 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 238: -#line 1822 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1824 "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 6671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6679 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 239: -#line 1827 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1829 "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 6681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6689 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 240: -#line 1832 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1834 "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 6691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6699 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 241: -#line 1837 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1839 "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 6701 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6709 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 242: -#line 1842 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1844 "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 6711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6719 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 243: -#line 1847 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1849 "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 6721 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6729 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 244: -#line 1852 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1854 "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 6731 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6739 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 245: -#line 1857 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1859 "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 6741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6749 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 246: -#line 1862 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1864 "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 6751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6759 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 247: -#line 1867 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1869 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -6760,11 +6768,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(2); } -#line 6764 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6772 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 248: -#line 1875 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1877 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -6773,11 +6781,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(3); } -#line 6777 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6785 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 249: -#line 1883 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1885 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -6786,374 +6794,374 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(4); } -#line 6790 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6798 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 250: -#line 1891 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1893 "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 6801 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6809 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 251: -#line 1897 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1899 "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 6812 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6820 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 252: -#line 1903 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1905 "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 6823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6831 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 253: -#line 1909 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1911 "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 6834 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6842 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 254: -#line 1915 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1917 "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 6845 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6853 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 255: -#line 1921 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1923 "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 6856 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6864 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 256: -#line 1927 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1929 "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 6867 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6875 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 257: -#line 1933 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1935 "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 6878 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6886 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 258: -#line 1939 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1941 "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 6889 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6897 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 259: -#line 1945 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1947 "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 6900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6908 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 260: -#line 1951 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1953 "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 6911 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6919 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 261: -#line 1957 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1959 "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 6922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6930 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 262: -#line 1963 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1965 "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 6933 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6941 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 263: -#line 1969 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1971 "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 6944 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6952 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 264: -#line 1975 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1977 "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 6955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6963 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 265: -#line 1981 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1983 "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 6966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6974 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 266: -#line 1987 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1989 "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 6977 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6985 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 267: -#line 1993 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 1995 "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 6988 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 6996 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 268: -#line 1999 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2001 "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 6999 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7007 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 269: -#line 2005 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2007 "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 7010 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7018 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 270: -#line 2011 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2013 "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 7021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7029 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 271: -#line 2017 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2019 "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 7032 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7040 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 272: -#line 2023 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2025 "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 7043 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7051 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 273: -#line 2029 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2031 "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 7054 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7062 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 274: -#line 2035 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2037 "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 7065 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7073 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 275: -#line 2041 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2043 "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 7076 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7084 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 276: -#line 2047 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2049 "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 7087 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7095 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 277: -#line 2053 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2055 "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 7098 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7106 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 278: -#line 2059 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2061 "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 7109 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7117 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 279: -#line 2065 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2067 "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 7120 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7128 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 280: -#line 2071 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2073 "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 7131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7139 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 281: -#line 2077 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2079 "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 7142 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7150 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 282: -#line 2083 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2085 "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 7153 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7161 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 283: -#line 2089 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2091 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7162,11 +7170,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 7166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7174 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 284: -#line 2097 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2099 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7175,11 +7183,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 7179 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7187 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 285: -#line 2105 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2107 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7188,11 +7196,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 7192 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7200 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 286: -#line 2113 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2115 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7201,11 +7209,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 7205 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7213 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 287: -#line 2121 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2123 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7214,11 +7222,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 3); } -#line 7218 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7226 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 288: -#line 2129 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2131 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7227,11 +7235,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 4); } -#line 7231 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7239 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 289: -#line 2137 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2139 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7240,11 +7248,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 2); } -#line 7244 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7252 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 290: -#line 2145 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2147 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7253,11 +7261,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 7257 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7265 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 291: -#line 2153 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2155 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7266,11 +7274,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 4); } -#line 7270 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7278 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 292: -#line 2161 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2163 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7279,11 +7287,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 2); } -#line 7283 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7291 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 293: -#line 2169 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2171 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7292,11 +7300,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 3); } -#line 7296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7304 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 294: -#line 2177 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2179 "glslang.y" /* yacc.c:1646 */ { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7305,1999 +7313,2008 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 7309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7317 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 295: -#line 2185 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2187 "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 7320 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7328 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 296: -#line 2191 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2193 "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 7331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7339 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 297: -#line 2197 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2199 "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 7342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7350 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 298: -#line 2203 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2205 "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 7353 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7361 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 299: -#line 2209 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2211 "glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 3); } -#line 7364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7372 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 300: -#line 2215 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2217 "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); } -#line 7375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7383 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 301: -#line 2221 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2223 "glslang.y" /* yacc.c:1646 */ { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(3, 2); } -#line 7386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7394 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 302: -#line 2227 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2229 "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 7397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7405 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 303: -#line 2233 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2235 "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 7408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7416 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 304: -#line 2239 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2241 "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 7419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7427 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 305: -#line 2245 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2247 "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 7430 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7438 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 306: -#line 2251 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2253 "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 7441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7449 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 307: -#line 2257 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2259 "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 7452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7460 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 308: -#line 2263 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2265 "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 7463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7471 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 309: -#line 2269 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2271 "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 7474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7482 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 310: -#line 2275 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2277 "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 7485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7493 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 311: -#line 2281 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2283 "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 7496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7504 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 312: -#line 2287 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2289 "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 7507 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7515 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 313: -#line 2293 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2295 "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 7518 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7526 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 314: -#line 2299 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2301 "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 7529 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7537 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 315: -#line 2305 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2307 "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 7540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7548 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 316: -#line 2311 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2313 "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 7551 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7559 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 317: -#line 2317 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2319 "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 7562 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7570 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 318: -#line 2323 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2325 "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 7573 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7581 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 319: -#line 2329 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2331 "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 7584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7592 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 320: -#line 2335 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2337 "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 7595 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7603 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 321: -#line 2341 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2343 "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 7606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7614 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 322: -#line 2347 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2349 "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 7617 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7625 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 323: -#line 2353 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2355 "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 7628 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7636 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 324: -#line 2359 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2361 "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 7639 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7647 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 325: -#line 2365 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2367 "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 7650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7658 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 326: -#line 2371 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2373 "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 7661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7669 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 327: -#line 2377 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2379 "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 7672 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7680 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 328: -#line 2383 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2385 "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 7683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7691 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 329: -#line 2389 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2391 "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 7694 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7702 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 330: -#line 2395 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2397 "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 7705 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7713 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 331: -#line 2401 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2403 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAccStruct; } -#line 7714 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7722 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 332: -#line 2405 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2407 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAccStruct; } -#line 7723 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7731 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 333: -#line 2409 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 2411 "glslang.y" /* yacc.c:1646 */ + { + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtRayQuery; + } +#line 7740 "glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 334: +#line 2415 "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 7733 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7750 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 334: -#line 2414 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 335: +#line 2420 "glslang.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 7743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7760 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 335: -#line 2420 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 336: +#line 2426 "glslang.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 7753 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7770 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 336: -#line 2425 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 337: +#line 2431 "glslang.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 7763 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7780 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 337: -#line 2430 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 338: +#line 2436 "glslang.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 7773 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7790 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 338: -#line 2435 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 339: +#line 2441 "glslang.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 7783 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7800 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 339: -#line 2440 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 340: +#line 2446 "glslang.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 7793 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7810 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 340: -#line 2445 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 341: +#line 2451 "glslang.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 7803 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7820 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 341: -#line 2450 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 342: +#line 2456 "glslang.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 7813 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7830 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 342: -#line 2456 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 343: +#line 2462 "glslang.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 7823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7840 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 343: -#line 2461 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 344: +#line 2467 "glslang.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 7833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7850 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 344: -#line 2466 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 345: +#line 2472 "glslang.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 7843 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7860 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 345: -#line 2471 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 346: +#line 2477 "glslang.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 7853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7870 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 346: -#line 2476 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 347: +#line 2482 "glslang.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 7863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7880 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 347: -#line 2481 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 348: +#line 2487 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D); } -#line 7874 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7891 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 348: -#line 2487 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 349: +#line 2493 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D); } -#line 7885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7902 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 349: -#line 2493 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 350: +#line 2499 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd3D); } -#line 7896 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7913 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 350: -#line 2499 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 351: +#line 2505 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube); } -#line 7907 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7924 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 351: -#line 2505 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 352: +#line 2511 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true); } -#line 7918 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7935 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 352: -#line 2511 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 353: +#line 2517 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true); } -#line 7929 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7946 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 353: -#line 2517 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 354: +#line 2523 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true); } -#line 7940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7957 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 354: -#line 2523 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 355: +#line 2529 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true); } -#line 7951 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7968 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 355: -#line 2529 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 356: +#line 2535 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true); } -#line 7962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7979 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 356: -#line 2535 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 357: +#line 2541 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true); } -#line 7973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 7990 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 357: -#line 2541 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 358: +#line 2547 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true); } -#line 7984 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8001 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 358: -#line 2547 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 359: +#line 2553 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true); } -#line 7995 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8012 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 359: -#line 2553 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 360: +#line 2559 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true); } -#line 8006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8023 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 360: -#line 2559 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 361: +#line 2565 "glslang.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 8016 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8033 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 361: -#line 2565 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 362: +#line 2571 "glslang.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 8026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8043 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 362: -#line 2570 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 363: +#line 2576 "glslang.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 8036 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8053 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 363: -#line 2575 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 364: +#line 2581 "glslang.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 8046 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8063 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 364: -#line 2580 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 365: +#line 2586 "glslang.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 8056 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8073 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 365: -#line 2585 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 366: +#line 2591 "glslang.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 8066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8083 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 366: -#line 2590 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 367: +#line 2596 "glslang.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 8076 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8093 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 367: -#line 2595 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 368: +#line 2601 "glslang.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 8086 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8103 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 368: -#line 2601 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 369: +#line 2607 "glslang.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 8096 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8113 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 369: -#line 2606 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 370: +#line 2612 "glslang.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 8106 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8123 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 370: -#line 2611 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 371: +#line 2617 "glslang.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 8116 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8133 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 371: -#line 2616 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 372: +#line 2622 "glslang.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 8126 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8143 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 372: -#line 2621 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 373: +#line 2627 "glslang.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 8136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8153 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 373: -#line 2626 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 374: +#line 2632 "glslang.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 8146 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8163 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 374: -#line 2631 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 375: +#line 2637 "glslang.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 8156 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8173 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 375: -#line 2636 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 376: +#line 2642 "glslang.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 8166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8183 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 376: -#line 2642 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 377: +#line 2648 "glslang.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 8176 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8193 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 377: -#line 2647 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 378: +#line 2653 "glslang.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 8186 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8203 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 378: -#line 2652 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 379: +#line 2658 "glslang.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 8196 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8213 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 379: -#line 2657 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 380: +#line 2663 "glslang.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 8206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8223 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 380: -#line 2662 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 381: +#line 2668 "glslang.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 8216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8233 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 381: -#line 2667 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 382: +#line 2673 "glslang.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 8226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8243 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 382: -#line 2672 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 383: +#line 2678 "glslang.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 8236 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8253 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 383: -#line 2677 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 384: +#line 2683 "glslang.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 8246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8263 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 384: -#line 2682 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 385: +#line 2688 "glslang.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 8256 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8273 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 385: -#line 2687 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 386: +#line 2693 "glslang.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 8266 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8283 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 386: -#line 2692 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 387: +#line 2698 "glslang.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 8276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8293 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 387: -#line 2697 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 388: +#line 2703 "glslang.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 8286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8303 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 388: -#line 2702 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 389: +#line 2708 "glslang.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 8296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8313 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 389: -#line 2707 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 390: +#line 2713 "glslang.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 8306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8323 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 390: -#line 2712 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 391: +#line 2718 "glslang.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 8316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8333 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 391: -#line 2718 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 392: +#line 2724 "glslang.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 8326 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8343 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 392: -#line 2723 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 393: +#line 2729 "glslang.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 8336 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8353 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 393: -#line 2728 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 394: +#line 2734 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdRect); } -#line 8347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8364 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 394: -#line 2734 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 395: +#line 2740 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true); } -#line 8358 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8375 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 395: -#line 2740 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 396: +#line 2746 "glslang.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 8368 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8385 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 396: -#line 2745 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 397: +#line 2751 "glslang.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 8378 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8395 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 397: -#line 2750 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 398: +#line 2756 "glslang.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 8388 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8405 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 398: -#line 2755 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 399: +#line 2761 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer); } -#line 8399 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8416 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 399: -#line 2761 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 400: +#line 2767 "glslang.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 8409 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8426 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 400: -#line 2766 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 401: +#line 2772 "glslang.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 8419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8436 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 401: -#line 2771 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 402: +#line 2777 "glslang.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 8429 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8446 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 402: -#line 2776 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 403: +#line 2782 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true); } -#line 8440 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8457 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 403: -#line 2782 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 404: +#line 2788 "glslang.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 8450 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8467 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 404: -#line 2787 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 405: +#line 2793 "glslang.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 8460 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8477 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 405: -#line 2792 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 406: +#line 2798 "glslang.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 8470 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8487 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 406: -#line 2797 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 407: +#line 2803 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true); } -#line 8481 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8498 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 407: -#line 2803 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 408: +#line 2809 "glslang.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 8491 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8508 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 408: -#line 2808 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 409: +#line 2814 "glslang.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 8501 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8518 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 409: -#line 2813 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 410: +#line 2819 "glslang.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 8511 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8528 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 410: -#line 2818 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 411: +#line 2824 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D); } -#line 8522 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8539 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 411: -#line 2824 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 412: +#line 2830 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D); } -#line 8533 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8550 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 412: -#line 2830 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 413: +#line 2836 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D); } -#line 8544 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8561 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 413: -#line 2836 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 414: +#line 2842 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube); } -#line 8555 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8572 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 414: -#line 2842 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 415: +#line 2848 "glslang.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 8565 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8582 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 415: -#line 2847 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 416: +#line 2853 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true); } -#line 8576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8593 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 416: -#line 2853 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 417: +#line 2859 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true); } -#line 8587 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8604 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 417: -#line 2859 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 418: +#line 2865 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true); } -#line 8598 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8615 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 418: -#line 2865 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 419: +#line 2871 "glslang.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 8608 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8625 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 419: -#line 2870 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 420: +#line 2876 "glslang.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 8618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8635 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 420: -#line 2875 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 421: +#line 2881 "glslang.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 8628 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8645 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 421: -#line 2880 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 422: +#line 2886 "glslang.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 8638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8655 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 422: -#line 2885 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 423: +#line 2891 "glslang.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 8648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8665 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 423: -#line 2890 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 424: +#line 2896 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect); } -#line 8659 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8676 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 424: -#line 2896 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 425: +#line 2902 "glslang.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 8669 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8686 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 425: -#line 2901 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 426: +#line 2907 "glslang.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 8679 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8696 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 426: -#line 2906 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 427: +#line 2912 "glslang.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 8689 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8706 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 427: -#line 2911 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 428: +#line 2917 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdBuffer); } -#line 8700 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8717 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 428: -#line 2917 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 429: +#line 2923 "glslang.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 8710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8727 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 429: -#line 2922 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 430: +#line 2928 "glslang.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 8720 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8737 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 430: -#line 2927 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 431: +#line 2933 "glslang.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 8730 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8747 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 431: -#line 2932 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 432: +#line 2938 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true); } -#line 8741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8758 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 432: -#line 2938 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 433: +#line 2944 "glslang.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 8751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8768 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 433: -#line 2943 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 434: +#line 2949 "glslang.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 8761 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8778 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 434: -#line 2948 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 435: +#line 2954 "glslang.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 8771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8788 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 435: -#line 2953 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 436: +#line 2959 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true); } -#line 8782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8799 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 436: -#line 2959 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 437: +#line 2965 "glslang.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 8792 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8809 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 437: -#line 2964 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 438: +#line 2970 "glslang.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 8802 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8819 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 438: -#line 2969 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 439: +#line 2975 "glslang.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 8812 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8829 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 439: -#line 2974 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 440: +#line 2980 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D); } -#line 8823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8840 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 440: -#line 2980 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 441: +#line 2986 "glslang.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 8833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8850 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 441: -#line 2985 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 442: +#line 2991 "glslang.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 8843 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8860 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 442: -#line 2990 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 443: +#line 2996 "glslang.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 8853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8870 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 443: -#line 2995 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 444: +#line 3001 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D); } -#line 8864 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8881 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 444: -#line 3001 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 445: +#line 3007 "glslang.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 8874 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8891 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 445: -#line 3006 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 446: +#line 3012 "glslang.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 8884 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8901 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 446: -#line 3011 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 447: +#line 3017 "glslang.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 8894 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8911 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 447: -#line 3016 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 448: +#line 3022 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D); } -#line 8905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8922 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 448: -#line 3022 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 449: +#line 3028 "glslang.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 8915 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8932 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 449: -#line 3027 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 450: +#line 3033 "glslang.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 8925 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8942 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 450: -#line 3032 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 451: +#line 3038 "glslang.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 8935 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8952 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 451: -#line 3037 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 452: +#line 3043 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect); } -#line 8946 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8963 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 452: -#line 3043 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 453: +#line 3049 "glslang.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 8956 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8973 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 453: -#line 3048 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 454: +#line 3054 "glslang.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 8966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8983 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 454: -#line 3053 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 455: +#line 3059 "glslang.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 8976 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 8993 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 455: -#line 3058 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 456: +#line 3064 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube); } -#line 8987 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9004 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 456: -#line 3064 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 457: +#line 3070 "glslang.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 8997 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9014 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 457: -#line 3069 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 458: +#line 3075 "glslang.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 9007 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9024 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 458: -#line 3074 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 459: +#line 3080 "glslang.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 9017 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9034 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 459: -#line 3079 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 460: +#line 3085 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer); } -#line 9028 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9045 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 460: -#line 3085 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 461: +#line 3091 "glslang.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 9038 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9055 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 461: -#line 3090 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 462: +#line 3096 "glslang.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 9048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9065 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 462: -#line 3095 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 463: +#line 3101 "glslang.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 9058 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9075 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 463: -#line 3100 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 464: +#line 3106 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true); } -#line 9069 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9086 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 464: -#line 3106 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 465: +#line 3112 "glslang.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 9079 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9096 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 465: -#line 3111 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 466: +#line 3117 "glslang.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 9089 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9106 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 466: -#line 3116 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 467: +#line 3122 "glslang.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 9099 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9116 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 467: -#line 3121 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 468: +#line 3127 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true); } -#line 9110 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9127 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 468: -#line 3127 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 469: +#line 3133 "glslang.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 9120 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9137 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 469: -#line 3132 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 470: +#line 3138 "glslang.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 9130 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9147 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 470: -#line 3137 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 471: +#line 3143 "glslang.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 9140 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9157 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 471: -#line 3142 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 472: +#line 3148 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true); } -#line 9151 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9168 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 472: -#line 3148 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 473: +#line 3154 "glslang.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 9161 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9178 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 473: -#line 3153 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 474: +#line 3159 "glslang.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 9171 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9188 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 474: -#line 3158 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 475: +#line 3164 "glslang.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 9181 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9198 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 475: -#line 3163 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 476: +#line 3169 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true); } -#line 9192 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9209 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 476: -#line 3169 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 477: +#line 3175 "glslang.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 9202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9219 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 477: -#line 3174 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 478: +#line 3180 "glslang.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 9212 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9229 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 478: -#line 3179 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 479: +#line 3185 "glslang.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 9222 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9239 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 479: -#line 3184 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 480: +#line 3190 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true); } -#line 9233 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9250 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 480: -#line 3190 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 481: +#line 3196 "glslang.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 9243 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9260 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 481: -#line 3195 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 482: +#line 3201 "glslang.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 9253 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9270 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 482: -#line 3200 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 483: +#line 3206 "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 9264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9281 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 483: -#line 3206 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 484: +#line 3212 "glslang.y" /* yacc.c:1646 */ { // GL_EXT_YUV_target (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); (yyval.interm.type).sampler.yuv = true; } -#line 9275 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9292 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 484: -#line 3212 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 485: +#line 3218 "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 9286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9303 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 485: -#line 3218 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 486: +#line 3224 "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 9297 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9314 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 486: -#line 3224 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 487: +#line 3230 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); @@ -9305,11 +9322,11 @@ yyreduce: (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat16); } -#line 9309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9326 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 487: -#line 3231 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 488: +#line 3237 "glslang.y" /* yacc.c:1646 */ { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); @@ -9317,98 +9334,98 @@ yyreduce: (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat16, true); } -#line 9321 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9338 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 488: -#line 3238 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 489: +#line 3244 "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 9332 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9349 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 489: -#line 3244 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 490: +#line 3250 "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 9343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9360 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 490: -#line 3250 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 491: +#line 3256 "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 9354 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9371 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 491: -#line 3256 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 492: +#line 3262 "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 9365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9382 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 492: -#line 3262 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 493: +#line 3268 "glslang.y" /* yacc.c:1646 */ { parseContext.fcoopmatCheck((yyvsp[0].lex).loc, "fcoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).coopmat = true; } -#line 9376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9393 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 493: -#line 3268 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 494: +#line 3274 "glslang.y" /* yacc.c:1646 */ { parseContext.intcoopmatCheck((yyvsp[0].lex).loc, "icoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).coopmat = true; } -#line 9387 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9404 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 494: -#line 3274 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 495: +#line 3280 "glslang.y" /* yacc.c:1646 */ { parseContext.intcoopmatCheck((yyvsp[0].lex).loc, "ucoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).coopmat = true; } -#line 9398 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9415 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 495: -#line 3281 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 496: +#line 3287 "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 9408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9425 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 496: -#line 3286 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 497: +#line 3292 "glslang.y" /* yacc.c:1646 */ { // // This is for user defined type names. The lexical phase looked up the @@ -9422,47 +9439,47 @@ yyreduce: } else parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), ""); } -#line 9426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9443 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 497: -#line 3302 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 498: +#line 3308 "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 9436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9453 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 498: -#line 3307 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 499: +#line 3313 "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 9446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9463 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 499: -#line 3312 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 500: +#line 3318 "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 9456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9473 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 500: -#line 3320 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 501: +#line 3326 "glslang.y" /* yacc.c:1646 */ { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); } -#line 9462 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9479 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 501: -#line 3320 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 502: +#line 3326 "glslang.y" /* yacc.c:1646 */ { TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string); parseContext.structArrayCheck((yyvsp[-4].lex).loc, *structure); @@ -9474,17 +9491,17 @@ yyreduce: (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 9478 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9495 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 502: -#line 3331 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 503: +#line 3337 "glslang.y" /* yacc.c:1646 */ { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); } -#line 9484 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9501 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 503: -#line 3331 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 504: +#line 3337 "glslang.y" /* yacc.c:1646 */ { TType* structure = new TType((yyvsp[-1].interm.typeList), TString("")); (yyval.interm.type).init((yyvsp[-4].lex).loc); @@ -9492,19 +9509,19 @@ yyreduce: (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 9496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9513 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 504: -#line 3341 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 505: +#line 3347 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList) = (yyvsp[0].interm.typeList); } -#line 9504 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9521 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 505: -#line 3344 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 506: +#line 3350 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) { @@ -9515,11 +9532,11 @@ yyreduce: (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]); } } -#line 9519 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9536 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 506: -#line 3357 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 507: +#line 3363 "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"); @@ -9542,11 +9559,11 @@ yyreduce: (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 9546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9563 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 507: -#line 3379 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 508: +#line 3385 "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"); @@ -9571,38 +9588,38 @@ yyreduce: (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 9575 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9592 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 508: -#line 3406 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 509: +#line 3412 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList) = new TTypeList; (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 9584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9601 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 509: -#line 3410 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 510: +#line 3416 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 9592 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9609 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 510: -#line 3416 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 511: +#line 3422 "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 9602 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9619 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 511: -#line 3421 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 512: +#line 3427 "glslang.y" /* yacc.c:1646 */ { parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes); @@ -9611,235 +9628,235 @@ yyreduce: (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string); (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes); } -#line 9615 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9632 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 512: -#line 3432 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 513: +#line 3438 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 9623 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9640 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 513: -#line 3436 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 514: +#line 3442 "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 9634 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9651 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 514: -#line 3442 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 515: +#line 3448 "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 9645 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9662 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 515: -#line 3453 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 516: +#line 3459 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc()); } -#line 9653 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9670 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 516: -#line 3456 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 517: +#line 3462 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); } -#line 9661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ - break; - - case 517: -#line 3463 "MachineIndependent/glslang.y" /* yacc.c:1646 */ - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9667 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9678 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 518: -#line 3467 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3469 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9673 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9684 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 519: -#line 3468 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3473 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9679 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9690 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 520: -#line 3474 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3474 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9685 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9696 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 521: -#line 3475 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3480 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9702 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 522: -#line 3476 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3481 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9708 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 523: -#line 3477 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3482 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9703 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9714 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 524: -#line 3478 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3483 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9720 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 525: -#line 3479 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3484 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9715 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9726 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 526: -#line 3480 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3485 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9721 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9732 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 527: -#line 3482 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3486 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9727 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9738 "glslang_tab.cpp" /* yacc.c:1646 */ break; case 528: -#line 3488 "MachineIndependent/glslang.y" /* yacc.c:1646 */ +#line 3488 "glslang.y" /* yacc.c:1646 */ + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 9744 "glslang_tab.cpp" /* yacc.c:1646 */ + break; + + case 529: +#line 3494 "glslang.y" /* yacc.c:1646 */ { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "demote"); parseContext.requireExtensions((yyvsp[-1].lex).loc, 1, &E_GL_EXT_demote_to_helper_invocation, "demote"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDemote, (yyvsp[-1].lex).loc); } -#line 9737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9754 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 529: -#line 3497 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 530: +#line 3503 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; } -#line 9743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9760 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 530: -#line 3498 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 531: +#line 3504 "glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; } -#line 9752 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9769 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 531: -#line 3502 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 532: +#line 3508 "glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; } -#line 9761 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9778 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 532: -#line 3506 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 533: +#line 3512 "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 9771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9788 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 533: -#line 3514 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 534: +#line 3520 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9777 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9794 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 534: -#line 3515 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 535: +#line 3521 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9783 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9800 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 535: -#line 3519 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 536: +#line 3525 "glslang.y" /* yacc.c:1646 */ { ++parseContext.controlFlowNestingLevel; } -#line 9791 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9808 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 536: -#line 3522 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 537: +#line 3528 "glslang.y" /* yacc.c:1646 */ { --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9800 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9817 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 537: -#line 3526 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 538: +#line 3532 "glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 9810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9827 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 538: -#line 3531 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 539: +#line 3537 "glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9821 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9838 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 539: -#line 3540 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 540: +#line 3546 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; } -#line 9829 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9846 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 540: -#line 3543 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 541: +#line 3549 "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 9839 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9856 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 541: -#line 3551 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 542: +#line 3557 "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 || @@ -9848,11 +9865,11 @@ yyreduce: (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case } } -#line 9852 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9869 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 542: -#line 3559 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 543: +#line 3565 "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)) { @@ -9861,76 +9878,76 @@ yyreduce: } else (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 9865 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9882 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 543: -#line 3570 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 544: +#line 3576 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; } -#line 9871 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9888 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 544: -#line 3571 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 545: +#line 3577 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = static_cast((yyvsp[-1].interm.intermTypedNode)); } -#line 9877 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9894 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 545: -#line 3575 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 546: +#line 3581 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9902 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 546: -#line 3579 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 547: +#line 3585 "glslang.y" /* yacc.c:1646 */ { parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9894 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9911 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 547: -#line 3586 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 548: +#line 3592 "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 9903 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9920 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 548: -#line 3593 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 549: +#line 3599 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode); } -#line 9912 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9929 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 549: -#line 3597 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 550: +#line 3603 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode); (yyval.interm.nodePair).node2 = 0; } -#line 9921 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9938 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 550: -#line 3605 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 551: +#line 3611 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)); } -#line 9930 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9947 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 551: -#line 3609 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 552: +#line 3615 "glslang.y" /* yacc.c:1646 */ { parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type)); @@ -9941,28 +9958,28 @@ yyreduce: else (yyval.interm.intermTypedNode) = 0; } -#line 9945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9962 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 552: -#line 3622 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 553: +#line 3628 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9970 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 553: -#line 3626 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 554: +#line 3632 "glslang.y" /* yacc.c:1646 */ { parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 9962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9979 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 554: -#line 3633 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 555: +#line 3639 "glslang.y" /* yacc.c:1646 */ { // start new switch sequence on the switch stack ++parseContext.controlFlowNestingLevel; @@ -9971,11 +9988,11 @@ yyreduce: parseContext.switchLevel.push_back(parseContext.statementNestingLevel); parseContext.symbolTable.push(); } -#line 9975 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 9992 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 555: -#line 3641 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 556: +#line 3647 "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(); @@ -9985,27 +10002,27 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 9989 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10006 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 556: -#line 3653 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 557: +#line 3659 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; } -#line 9997 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10014 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 557: -#line 3656 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 558: +#line 3662 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 10005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10022 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 558: -#line 3662 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 559: +#line 3668 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -10018,11 +10035,11 @@ yyreduce: (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc); } } -#line 10022 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10039 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 559: -#line 3674 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 560: +#line 3680 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -10032,28 +10049,28 @@ yyreduce: else (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc); } -#line 10036 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10053 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 560: -#line 3686 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 561: +#line 3692 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 10044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10061 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 561: -#line 3690 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 562: +#line 3696 "glslang.y" /* yacc.c:1646 */ { parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 10053 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10070 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 562: -#line 3697 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 563: +#line 3703 "glslang.y" /* yacc.c:1646 */ { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", ""); @@ -10062,11 +10079,11 @@ yyreduce: ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 10066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10083 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 563: -#line 3705 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 564: +#line 3711 "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); @@ -10074,21 +10091,21 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 10078 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10095 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 564: -#line 3712 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 565: +#line 3718 "glslang.y" /* yacc.c:1646 */ { ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 10088 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10105 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 565: -#line 3717 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 566: +#line 3723 "glslang.y" /* yacc.c:1646 */ { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", ""); @@ -10100,22 +10117,22 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 10104 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10121 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 566: -#line 3728 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 567: +#line 3734 "glslang.y" /* yacc.c:1646 */ { parseContext.symbolTable.push(); ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 10115 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10132 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 567: -#line 3734 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 568: +#line 3740 "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); @@ -10128,81 +10145,81 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 10132 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10149 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 568: -#line 3749 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 569: +#line 3755 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 10140 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10157 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 569: -#line 3752 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 570: +#line 3758 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 10148 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10165 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 570: -#line 3758 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 571: +#line 3764 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 10156 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10173 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 571: -#line 3761 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 572: +#line 3767 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermTypedNode) = 0; } -#line 10164 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10181 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 572: -#line 3767 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 573: +#line 3773 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode); (yyval.interm.nodePair).node2 = 0; } -#line 10173 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10190 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 573: -#line 3771 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 574: +#line 3777 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode); } -#line 10182 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10199 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 574: -#line 3778 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 575: +#line 3784 "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 10192 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10209 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 575: -#line 3783 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 576: +#line 3789 "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 10202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10219 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 576: -#line 3788 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 577: +#line 3794 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc); if (parseContext.currentFunctionType->getBasicType() != EbtVoid) @@ -10210,83 +10227,83 @@ yyreduce: if (parseContext.inMain) parseContext.postEntryPointReturn = true; } -#line 10214 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10231 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 577: -#line 3795 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 578: +#line 3801 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode)); } -#line 10222 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10239 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 578: -#line 3798 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 579: +#line 3804 "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 10231 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10248 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 579: -#line 3807 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 580: +#line 3813 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } -#line 10240 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10257 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 580: -#line 3811 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 581: +#line 3817 "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 10251 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10268 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 581: -#line 3820 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 582: +#line 3826 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 10259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10276 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 582: -#line 3823 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 583: +#line 3829 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 10267 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10284 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 583: -#line 3827 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 584: +#line 3833 "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 10277 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10294 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 584: -#line 3836 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 585: +#line 3842 "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 10286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10303 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 585: -#line 3840 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 586: +#line 3846 "glslang.y" /* yacc.c:1646 */ { // May be best done as post process phase on intermediate code if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue) @@ -10302,52 +10319,52 @@ yyreduce: (yyval.interm.intermNode)->getAsAggregate()->setDebug(parseContext.contextPragma.debug); (yyval.interm.intermNode)->getAsAggregate()->setPragmaTable(parseContext.contextPragma.pragmaTable); } -#line 10306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10323 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 586: -#line 3859 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 587: +#line 3865 "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 10315 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10332 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 587: -#line 3865 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 588: +#line 3871 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.attributes) = (yyvsp[0].interm.attributes); } -#line 10323 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10340 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 588: -#line 3868 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 589: +#line 3874 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes)); } -#line 10331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10348 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 589: -#line 3873 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 590: +#line 3879 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string); } -#line 10339 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10356 "glslang_tab.cpp" /* yacc.c:1646 */ break; - case 590: -#line 3876 "MachineIndependent/glslang.y" /* yacc.c:1646 */ + case 591: +#line 3882 "glslang.y" /* yacc.c:1646 */ { (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode)); } -#line 10347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10364 "glslang_tab.cpp" /* yacc.c:1646 */ break; -#line 10351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ +#line 10368 "glslang_tab.cpp" /* yacc.c:1646 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -10575,5 +10592,6 @@ yyreturn: #endif return yyresult; } -#line 3881 "MachineIndependent/glslang.y" /* yacc.c:1906 */ +#line 3887 "glslang.y" /* yacc.c:1906 */ + diff --git a/glslang/MachineIndependent/glslang_tab.cpp.h b/glslang/MachineIndependent/glslang_tab.cpp.h index 6f3dfb93..31c8f902 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp.h +++ b/glslang/MachineIndependent/glslang_tab.cpp.h @@ -30,8 +30,8 @@ This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ -#ifndef YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED -# define YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED +#ifndef YY_YY_GLSLANG_TAB_CPP_H_INCLUDED +# define YY_YY_GLSLANG_TAB_CPP_H_INCLUDED /* Debug traces. */ #ifndef YYDEBUG # define YYDEBUG 1 @@ -204,263 +204,264 @@ extern int yydebug; ATOMIC_UINT = 414, ACCSTRUCTNV = 415, ACCSTRUCTEXT = 416, - FCOOPMATNV = 417, - ICOOPMATNV = 418, - UCOOPMATNV = 419, - SAMPLERCUBEARRAY = 420, - SAMPLERCUBEARRAYSHADOW = 421, - ISAMPLERCUBEARRAY = 422, - USAMPLERCUBEARRAY = 423, - SAMPLER1D = 424, - SAMPLER1DARRAY = 425, - SAMPLER1DARRAYSHADOW = 426, - ISAMPLER1D = 427, - SAMPLER1DSHADOW = 428, - SAMPLER2DRECT = 429, - SAMPLER2DRECTSHADOW = 430, - ISAMPLER2DRECT = 431, - USAMPLER2DRECT = 432, - SAMPLERBUFFER = 433, - ISAMPLERBUFFER = 434, - USAMPLERBUFFER = 435, - SAMPLER2DMS = 436, - ISAMPLER2DMS = 437, - USAMPLER2DMS = 438, - SAMPLER2DMSARRAY = 439, - ISAMPLER2DMSARRAY = 440, - USAMPLER2DMSARRAY = 441, - SAMPLEREXTERNALOES = 442, - SAMPLEREXTERNAL2DY2YEXT = 443, - ISAMPLER1DARRAY = 444, - USAMPLER1D = 445, - USAMPLER1DARRAY = 446, - F16SAMPLER1D = 447, - F16SAMPLER2D = 448, - F16SAMPLER3D = 449, - F16SAMPLER2DRECT = 450, - F16SAMPLERCUBE = 451, - F16SAMPLER1DARRAY = 452, - F16SAMPLER2DARRAY = 453, - F16SAMPLERCUBEARRAY = 454, - F16SAMPLERBUFFER = 455, - F16SAMPLER2DMS = 456, - F16SAMPLER2DMSARRAY = 457, - F16SAMPLER1DSHADOW = 458, - F16SAMPLER2DSHADOW = 459, - F16SAMPLER1DARRAYSHADOW = 460, - F16SAMPLER2DARRAYSHADOW = 461, - F16SAMPLER2DRECTSHADOW = 462, - F16SAMPLERCUBESHADOW = 463, - F16SAMPLERCUBEARRAYSHADOW = 464, - IMAGE1D = 465, - IIMAGE1D = 466, - UIMAGE1D = 467, - IMAGE2D = 468, - IIMAGE2D = 469, - UIMAGE2D = 470, - IMAGE3D = 471, - IIMAGE3D = 472, - UIMAGE3D = 473, - IMAGE2DRECT = 474, - IIMAGE2DRECT = 475, - UIMAGE2DRECT = 476, - IMAGECUBE = 477, - IIMAGECUBE = 478, - UIMAGECUBE = 479, - IMAGEBUFFER = 480, - IIMAGEBUFFER = 481, - UIMAGEBUFFER = 482, - IMAGE1DARRAY = 483, - IIMAGE1DARRAY = 484, - UIMAGE1DARRAY = 485, - IMAGE2DARRAY = 486, - IIMAGE2DARRAY = 487, - UIMAGE2DARRAY = 488, - IMAGECUBEARRAY = 489, - IIMAGECUBEARRAY = 490, - UIMAGECUBEARRAY = 491, - IMAGE2DMS = 492, - IIMAGE2DMS = 493, - UIMAGE2DMS = 494, - IMAGE2DMSARRAY = 495, - IIMAGE2DMSARRAY = 496, - UIMAGE2DMSARRAY = 497, - F16IMAGE1D = 498, - F16IMAGE2D = 499, - F16IMAGE3D = 500, - F16IMAGE2DRECT = 501, - F16IMAGECUBE = 502, - F16IMAGE1DARRAY = 503, - F16IMAGE2DARRAY = 504, - F16IMAGECUBEARRAY = 505, - F16IMAGEBUFFER = 506, - F16IMAGE2DMS = 507, - F16IMAGE2DMSARRAY = 508, - TEXTURECUBEARRAY = 509, - ITEXTURECUBEARRAY = 510, - UTEXTURECUBEARRAY = 511, - TEXTURE1D = 512, - ITEXTURE1D = 513, - UTEXTURE1D = 514, - TEXTURE1DARRAY = 515, - ITEXTURE1DARRAY = 516, - UTEXTURE1DARRAY = 517, - TEXTURE2DRECT = 518, - ITEXTURE2DRECT = 519, - UTEXTURE2DRECT = 520, - TEXTUREBUFFER = 521, - ITEXTUREBUFFER = 522, - UTEXTUREBUFFER = 523, - TEXTURE2DMS = 524, - ITEXTURE2DMS = 525, - UTEXTURE2DMS = 526, - TEXTURE2DMSARRAY = 527, - ITEXTURE2DMSARRAY = 528, - UTEXTURE2DMSARRAY = 529, - F16TEXTURE1D = 530, - F16TEXTURE2D = 531, - F16TEXTURE3D = 532, - F16TEXTURE2DRECT = 533, - F16TEXTURECUBE = 534, - F16TEXTURE1DARRAY = 535, - F16TEXTURE2DARRAY = 536, - F16TEXTURECUBEARRAY = 537, - F16TEXTUREBUFFER = 538, - F16TEXTURE2DMS = 539, - F16TEXTURE2DMSARRAY = 540, - SUBPASSINPUT = 541, - SUBPASSINPUTMS = 542, - ISUBPASSINPUT = 543, - ISUBPASSINPUTMS = 544, - USUBPASSINPUT = 545, - USUBPASSINPUTMS = 546, - F16SUBPASSINPUT = 547, - F16SUBPASSINPUTMS = 548, - LEFT_OP = 549, - RIGHT_OP = 550, - INC_OP = 551, - DEC_OP = 552, - LE_OP = 553, - GE_OP = 554, - EQ_OP = 555, - NE_OP = 556, - AND_OP = 557, - OR_OP = 558, - XOR_OP = 559, - MUL_ASSIGN = 560, - DIV_ASSIGN = 561, - ADD_ASSIGN = 562, - MOD_ASSIGN = 563, - LEFT_ASSIGN = 564, - RIGHT_ASSIGN = 565, - AND_ASSIGN = 566, - XOR_ASSIGN = 567, - OR_ASSIGN = 568, - SUB_ASSIGN = 569, - STRING_LITERAL = 570, - LEFT_PAREN = 571, - RIGHT_PAREN = 572, - LEFT_BRACKET = 573, - RIGHT_BRACKET = 574, - LEFT_BRACE = 575, - RIGHT_BRACE = 576, - DOT = 577, - COMMA = 578, - COLON = 579, - EQUAL = 580, - SEMICOLON = 581, - BANG = 582, - DASH = 583, - TILDE = 584, - PLUS = 585, - STAR = 586, - SLASH = 587, - PERCENT = 588, - LEFT_ANGLE = 589, - RIGHT_ANGLE = 590, - VERTICAL_BAR = 591, - CARET = 592, - AMPERSAND = 593, - QUESTION = 594, - INVARIANT = 595, - HIGH_PRECISION = 596, - MEDIUM_PRECISION = 597, - LOW_PRECISION = 598, - PRECISION = 599, - PACKED = 600, - RESOURCE = 601, - SUPERP = 602, - FLOATCONSTANT = 603, - INTCONSTANT = 604, - UINTCONSTANT = 605, - BOOLCONSTANT = 606, - IDENTIFIER = 607, - TYPE_NAME = 608, - CENTROID = 609, - IN = 610, - OUT = 611, - INOUT = 612, - STRUCT = 613, - VOID = 614, - WHILE = 615, - BREAK = 616, - CONTINUE = 617, - DO = 618, - ELSE = 619, - FOR = 620, - IF = 621, - DISCARD = 622, - RETURN = 623, - SWITCH = 624, - CASE = 625, - DEFAULT = 626, - UNIFORM = 627, - SHARED = 628, - BUFFER = 629, - FLAT = 630, - SMOOTH = 631, - LAYOUT = 632, - DOUBLECONSTANT = 633, - INT16CONSTANT = 634, - UINT16CONSTANT = 635, - FLOAT16CONSTANT = 636, - INT32CONSTANT = 637, - UINT32CONSTANT = 638, - INT64CONSTANT = 639, - UINT64CONSTANT = 640, - SUBROUTINE = 641, - DEMOTE = 642, - PAYLOADNV = 643, - PAYLOADINNV = 644, - HITATTRNV = 645, - CALLDATANV = 646, - CALLDATAINNV = 647, - PAYLOADEXT = 648, - PAYLOADINEXT = 649, - HITATTREXT = 650, - CALLDATAEXT = 651, - CALLDATAINEXT = 652, - PATCH = 653, - SAMPLE = 654, - NONUNIFORM = 655, - COHERENT = 656, - VOLATILE = 657, - RESTRICT = 658, - READONLY = 659, - WRITEONLY = 660, - DEVICECOHERENT = 661, - QUEUEFAMILYCOHERENT = 662, - WORKGROUPCOHERENT = 663, - SUBGROUPCOHERENT = 664, - NONPRIVATE = 665, - SHADERCALLCOHERENT = 666, - NOPERSPECTIVE = 667, - EXPLICITINTERPAMD = 668, - PERVERTEXNV = 669, - PERPRIMITIVENV = 670, - PERVIEWNV = 671, - PERTASKNV = 672, - PRECISE = 673 + RAYQUERYEXT = 417, + FCOOPMATNV = 418, + ICOOPMATNV = 419, + UCOOPMATNV = 420, + SAMPLERCUBEARRAY = 421, + SAMPLERCUBEARRAYSHADOW = 422, + ISAMPLERCUBEARRAY = 423, + USAMPLERCUBEARRAY = 424, + SAMPLER1D = 425, + SAMPLER1DARRAY = 426, + SAMPLER1DARRAYSHADOW = 427, + ISAMPLER1D = 428, + SAMPLER1DSHADOW = 429, + SAMPLER2DRECT = 430, + SAMPLER2DRECTSHADOW = 431, + ISAMPLER2DRECT = 432, + USAMPLER2DRECT = 433, + SAMPLERBUFFER = 434, + ISAMPLERBUFFER = 435, + USAMPLERBUFFER = 436, + SAMPLER2DMS = 437, + ISAMPLER2DMS = 438, + USAMPLER2DMS = 439, + SAMPLER2DMSARRAY = 440, + ISAMPLER2DMSARRAY = 441, + USAMPLER2DMSARRAY = 442, + SAMPLEREXTERNALOES = 443, + SAMPLEREXTERNAL2DY2YEXT = 444, + ISAMPLER1DARRAY = 445, + USAMPLER1D = 446, + USAMPLER1DARRAY = 447, + F16SAMPLER1D = 448, + F16SAMPLER2D = 449, + F16SAMPLER3D = 450, + F16SAMPLER2DRECT = 451, + F16SAMPLERCUBE = 452, + F16SAMPLER1DARRAY = 453, + F16SAMPLER2DARRAY = 454, + F16SAMPLERCUBEARRAY = 455, + F16SAMPLERBUFFER = 456, + F16SAMPLER2DMS = 457, + F16SAMPLER2DMSARRAY = 458, + F16SAMPLER1DSHADOW = 459, + F16SAMPLER2DSHADOW = 460, + F16SAMPLER1DARRAYSHADOW = 461, + F16SAMPLER2DARRAYSHADOW = 462, + F16SAMPLER2DRECTSHADOW = 463, + F16SAMPLERCUBESHADOW = 464, + F16SAMPLERCUBEARRAYSHADOW = 465, + IMAGE1D = 466, + IIMAGE1D = 467, + UIMAGE1D = 468, + IMAGE2D = 469, + IIMAGE2D = 470, + UIMAGE2D = 471, + IMAGE3D = 472, + IIMAGE3D = 473, + UIMAGE3D = 474, + IMAGE2DRECT = 475, + IIMAGE2DRECT = 476, + UIMAGE2DRECT = 477, + IMAGECUBE = 478, + IIMAGECUBE = 479, + UIMAGECUBE = 480, + IMAGEBUFFER = 481, + IIMAGEBUFFER = 482, + UIMAGEBUFFER = 483, + IMAGE1DARRAY = 484, + IIMAGE1DARRAY = 485, + UIMAGE1DARRAY = 486, + IMAGE2DARRAY = 487, + IIMAGE2DARRAY = 488, + UIMAGE2DARRAY = 489, + IMAGECUBEARRAY = 490, + IIMAGECUBEARRAY = 491, + UIMAGECUBEARRAY = 492, + IMAGE2DMS = 493, + IIMAGE2DMS = 494, + UIMAGE2DMS = 495, + IMAGE2DMSARRAY = 496, + IIMAGE2DMSARRAY = 497, + UIMAGE2DMSARRAY = 498, + F16IMAGE1D = 499, + F16IMAGE2D = 500, + F16IMAGE3D = 501, + F16IMAGE2DRECT = 502, + F16IMAGECUBE = 503, + F16IMAGE1DARRAY = 504, + F16IMAGE2DARRAY = 505, + F16IMAGECUBEARRAY = 506, + F16IMAGEBUFFER = 507, + F16IMAGE2DMS = 508, + F16IMAGE2DMSARRAY = 509, + TEXTURECUBEARRAY = 510, + ITEXTURECUBEARRAY = 511, + UTEXTURECUBEARRAY = 512, + TEXTURE1D = 513, + ITEXTURE1D = 514, + UTEXTURE1D = 515, + TEXTURE1DARRAY = 516, + ITEXTURE1DARRAY = 517, + UTEXTURE1DARRAY = 518, + TEXTURE2DRECT = 519, + ITEXTURE2DRECT = 520, + UTEXTURE2DRECT = 521, + TEXTUREBUFFER = 522, + ITEXTUREBUFFER = 523, + UTEXTUREBUFFER = 524, + TEXTURE2DMS = 525, + ITEXTURE2DMS = 526, + UTEXTURE2DMS = 527, + TEXTURE2DMSARRAY = 528, + ITEXTURE2DMSARRAY = 529, + UTEXTURE2DMSARRAY = 530, + F16TEXTURE1D = 531, + F16TEXTURE2D = 532, + F16TEXTURE3D = 533, + F16TEXTURE2DRECT = 534, + F16TEXTURECUBE = 535, + F16TEXTURE1DARRAY = 536, + F16TEXTURE2DARRAY = 537, + F16TEXTURECUBEARRAY = 538, + F16TEXTUREBUFFER = 539, + F16TEXTURE2DMS = 540, + F16TEXTURE2DMSARRAY = 541, + SUBPASSINPUT = 542, + SUBPASSINPUTMS = 543, + ISUBPASSINPUT = 544, + ISUBPASSINPUTMS = 545, + USUBPASSINPUT = 546, + USUBPASSINPUTMS = 547, + F16SUBPASSINPUT = 548, + F16SUBPASSINPUTMS = 549, + LEFT_OP = 550, + RIGHT_OP = 551, + INC_OP = 552, + DEC_OP = 553, + LE_OP = 554, + GE_OP = 555, + EQ_OP = 556, + NE_OP = 557, + AND_OP = 558, + OR_OP = 559, + XOR_OP = 560, + MUL_ASSIGN = 561, + DIV_ASSIGN = 562, + ADD_ASSIGN = 563, + MOD_ASSIGN = 564, + LEFT_ASSIGN = 565, + RIGHT_ASSIGN = 566, + AND_ASSIGN = 567, + XOR_ASSIGN = 568, + OR_ASSIGN = 569, + SUB_ASSIGN = 570, + STRING_LITERAL = 571, + LEFT_PAREN = 572, + RIGHT_PAREN = 573, + LEFT_BRACKET = 574, + RIGHT_BRACKET = 575, + LEFT_BRACE = 576, + RIGHT_BRACE = 577, + DOT = 578, + COMMA = 579, + COLON = 580, + EQUAL = 581, + SEMICOLON = 582, + BANG = 583, + DASH = 584, + TILDE = 585, + PLUS = 586, + STAR = 587, + SLASH = 588, + PERCENT = 589, + LEFT_ANGLE = 590, + RIGHT_ANGLE = 591, + VERTICAL_BAR = 592, + CARET = 593, + AMPERSAND = 594, + QUESTION = 595, + INVARIANT = 596, + HIGH_PRECISION = 597, + MEDIUM_PRECISION = 598, + LOW_PRECISION = 599, + PRECISION = 600, + PACKED = 601, + RESOURCE = 602, + SUPERP = 603, + FLOATCONSTANT = 604, + INTCONSTANT = 605, + UINTCONSTANT = 606, + BOOLCONSTANT = 607, + IDENTIFIER = 608, + TYPE_NAME = 609, + CENTROID = 610, + IN = 611, + OUT = 612, + INOUT = 613, + STRUCT = 614, + VOID = 615, + WHILE = 616, + BREAK = 617, + CONTINUE = 618, + DO = 619, + ELSE = 620, + FOR = 621, + IF = 622, + DISCARD = 623, + RETURN = 624, + SWITCH = 625, + CASE = 626, + DEFAULT = 627, + UNIFORM = 628, + SHARED = 629, + BUFFER = 630, + FLAT = 631, + SMOOTH = 632, + LAYOUT = 633, + DOUBLECONSTANT = 634, + INT16CONSTANT = 635, + UINT16CONSTANT = 636, + FLOAT16CONSTANT = 637, + INT32CONSTANT = 638, + UINT32CONSTANT = 639, + INT64CONSTANT = 640, + UINT64CONSTANT = 641, + SUBROUTINE = 642, + DEMOTE = 643, + PAYLOADNV = 644, + PAYLOADINNV = 645, + HITATTRNV = 646, + CALLDATANV = 647, + CALLDATAINNV = 648, + PAYLOADEXT = 649, + PAYLOADINEXT = 650, + HITATTREXT = 651, + CALLDATAEXT = 652, + CALLDATAINEXT = 653, + PATCH = 654, + SAMPLE = 655, + NONUNIFORM = 656, + COHERENT = 657, + VOLATILE = 658, + RESTRICT = 659, + READONLY = 660, + WRITEONLY = 661, + DEVICECOHERENT = 662, + QUEUEFAMILYCOHERENT = 663, + WORKGROUPCOHERENT = 664, + SUBGROUPCOHERENT = 665, + NONPRIVATE = 666, + SHADERCALLCOHERENT = 667, + NOPERSPECTIVE = 668, + EXPLICITINTERPAMD = 669, + PERVERTEXNV = 670, + PERPRIMITIVENV = 671, + PERVIEWNV = 672, + PERTASKNV = 673, + PRECISE = 674 }; #endif @@ -469,7 +470,7 @@ extern int yydebug; union YYSTYPE { -#line 96 "MachineIndependent/glslang.y" /* yacc.c:1909 */ +#line 97 "glslang.y" /* yacc.c:1909 */ struct { glslang::TSourceLoc loc; @@ -505,7 +506,7 @@ union YYSTYPE glslang::TArraySizes* typeParameters; } interm; -#line 509 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909 */ +#line 510 "glslang_tab.cpp.h" /* yacc.c:1909 */ }; typedef union YYSTYPE YYSTYPE; @@ -517,4 +518,4 @@ typedef union YYSTYPE YYSTYPE; int yyparse (glslang::TParseContext* pParseContext); -#endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED */ +#endif /* !YY_YY_GLSLANG_TAB_CPP_H_INCLUDED */ diff --git a/glslang/MachineIndependent/intermOut.cpp b/glslang/MachineIndependent/intermOut.cpp index 53dc35da..c5417035 100644 --- a/glslang/MachineIndependent/intermOut.cpp +++ b/glslang/MachineIndependent/intermOut.cpp @@ -2,6 +2,7 @@ // Copyright (C) 2002-2005 3Dlabs Inc. Ltd. // Copyright (C) 2012-2016 LunarG, Inc. // Copyright (C) 2017 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. // // All rights reserved. // @@ -1085,6 +1086,30 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpExecuteCallable: out.debug << "executeCallableNV"; break; case EOpWritePackedPrimitiveIndices4x8NV: out.debug << "writePackedPrimitiveIndices4x8NV"; break; + case EOpRayQueryInitialize: out.debug << "rayQueryInitializeEXT"; break; + case EOpRayQueryTerminate: out.debug << "rayQueryTerminateEXT"; break; + case EOpRayQueryGenerateIntersection: out.debug << "rayQueryGenerateIntersectionEXT"; break; + case EOpRayQueryConfirmIntersection: out.debug << "rayQueryConfirmIntersectionEXT"; break; + case EOpRayQueryProceed: out.debug << "rayQueryProceedEXT"; break; + case EOpRayQueryGetIntersectionType: out.debug << "rayQueryGetIntersectionTypeEXT"; break; + case EOpRayQueryGetRayTMin: out.debug << "rayQueryGetRayTMinEXT"; break; + case EOpRayQueryGetRayFlags: out.debug << "rayQueryGetRayFlagsEXT"; break; + case EOpRayQueryGetIntersectionT: out.debug << "rayQueryGetIntersectionTEXT"; break; + case EOpRayQueryGetIntersectionInstanceCustomIndex: out.debug << "rayQueryGetIntersectionInstanceCustomIndexEXT"; break; + case EOpRayQueryGetIntersectionInstanceId: out.debug << "rayQueryGetIntersectionInstanceIdEXT"; break; + case EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset: out.debug << "rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT"; break; + case EOpRayQueryGetIntersectionGeometryIndex: out.debug << "rayQueryGetIntersectionGeometryIndexEXT"; break; + case EOpRayQueryGetIntersectionPrimitiveIndex: out.debug << "rayQueryGetIntersectionPrimitiveIndexEXT"; break; + case EOpRayQueryGetIntersectionBarycentrics: out.debug << "rayQueryGetIntersectionBarycentricsEXT"; break; + case EOpRayQueryGetIntersectionFrontFace: out.debug << "rayQueryGetIntersectionFrontFaceEXT"; break; + case EOpRayQueryGetIntersectionCandidateAABBOpaque: out.debug << "rayQueryGetIntersectionCandidateAABBOpaqueEXT"; break; + case EOpRayQueryGetIntersectionObjectRayDirection: out.debug << "rayQueryGetIntersectionObjectRayDirectionEXT"; break; + case EOpRayQueryGetIntersectionObjectRayOrigin: out.debug << "rayQueryGetIntersectionObjectRayOriginEXT"; break; + case EOpRayQueryGetWorldRayDirection: out.debug << "rayQueryGetWorldRayDirectionEXT"; break; + case EOpRayQueryGetWorldRayOrigin: out.debug << "rayQueryGetWorldRayOriginEXT"; break; + case EOpRayQueryGetIntersectionObjectToWorld: out.debug << "rayQueryGetIntersectionObjectToWorldEXT"; break; + case EOpRayQueryGetIntersectionWorldToObject: out.debug << "rayQueryGetIntersectionWorldToObjectEXT"; break; + case EOpCooperativeMatrixLoad: out.debug << "Load cooperative matrix"; break; case EOpCooperativeMatrixStore: out.debug << "Store cooperative matrix"; break; case EOpCooperativeMatrixMulAdd: out.debug << "MulAdd cooperative matrices"; break; -- 2.34.1