| // | |
| // Copyright (C) 2016 Google, Inc. | |
| // | |
| // All rights reserved. | |
| // | |
| // Redistribution and use in source and binary forms, with or without | |
| // modification, are permitted provided that the following conditions | |
| // are met: | |
| // | |
| // Redistributions of source code must retain the above copyright | |
| // notice, this list of conditions and the following disclaimer. | |
| // | |
| // Redistributions in binary form must reproduce the above | |
| // copyright notice, this list of conditions and the following | |
| // disclaimer in the documentation and/or other materials provided | |
| // with the distribution. | |
| // | |
| // Neither the name of Google, Inc., nor the names of its | |
| // contributors may be used to endorse or promote products derived | |
| // from this software without specific prior written permission. | |
| // | |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS | |
| // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE | |
| // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, | |
| // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, | |
| // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
| // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
| // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN | |
| // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
| // POSSIBILITY OF SUCH DAMAGE. | |
| // | |
| // Map from physical token form (e.g. '-') to logical operator | |
| // form (e.g., binary subtract or unary negate). | |
| #include "hlslOpMap.h" | |
| namespace glslang { | |
| // Map parsing tokens that could be assignments into assignment operators. | |
| TOperator HlslOpMap::assignment(EHlslTokenClass op) | |
| { | |
| switch (op) { | |
| case EHTokAssign: return EOpAssign; | |
| case EHTokMulAssign: return EOpMulAssign; | |
| case EHTokDivAssign: return EOpDivAssign; | |
| case EHTokAddAssign: return EOpAddAssign; | |
| case EHTokModAssign: return EOpModAssign; | |
| case EHTokLeftAssign: return EOpLeftShiftAssign; | |
| case EHTokRightAssign: return EOpRightShiftAssign; | |
| case EHTokAndAssign: return EOpAndAssign; | |
| case EHTokXorAssign: return EOpExclusiveOrAssign; | |
| case EHTokOrAssign: return EOpInclusiveOrAssign; | |
| case EHTokSubAssign: return EOpSubAssign; | |
| default: | |
| return EOpNull; | |
| } | |
| } | |
| // Map parsing tokens that could be binary operations into binary operators. | |
| TOperator HlslOpMap::binary(EHlslTokenClass op) | |
| { | |
| switch (op) { | |
| case EHTokPlus: return EOpAdd; | |
| case EHTokDash: return EOpSub; | |
| case EHTokStar: return EOpMul; | |
| case EHTokSlash: return EOpDiv; | |
| case EHTokPercent: return EOpMod; | |
| case EHTokRightOp: return EOpRightShift; | |
| case EHTokLeftOp: return EOpLeftShift; | |
| case EHTokAmpersand: return EOpAnd; | |
| case EHTokVerticalBar: return EOpInclusiveOr; | |
| case EHTokCaret: return EOpExclusiveOr; | |
| case EHTokEqOp: return EOpEqual; | |
| case EHTokNeOp: return EOpNotEqual; | |
| case EHTokLeftAngle: return EOpLessThan; | |
| case EHTokRightAngle: return EOpGreaterThan; | |
| case EHTokLeOp: return EOpLessThanEqual; | |
| case EHTokGeOp: return EOpGreaterThanEqual; | |
| case EHTokOrOp: return EOpLogicalOr; | |
| case EHTokXorOp: return EOpLogicalXor; | |
| case EHTokAndOp: return EOpLogicalAnd; | |
| default: | |
| return EOpNull; | |
| } | |
| } | |
| // Map parsing tokens that could be unary operations into unary operators. | |
| // These are just the ones that can appear in front of its operand. | |
| TOperator HlslOpMap::preUnary(EHlslTokenClass op) | |
| { | |
| switch (op) { | |
| case EHTokPlus: return EOpAdd; // means no-op, but still a unary op was present | |
| case EHTokDash: return EOpNegative; | |
| case EHTokBang: return EOpLogicalNot; | |
| case EHTokTilde: return EOpBitwiseNot; | |
| case EHTokIncOp: return EOpPreIncrement; | |
| case EHTokDecOp: return EOpPreDecrement; | |
| default: return EOpNull; // means not a pre-unary op | |
| } | |
| } | |
| // Map parsing tokens that could be unary operations into unary operators. | |
| // These are just the ones that can appear behind its operand. | |
| TOperator HlslOpMap::postUnary(EHlslTokenClass op) | |
| { | |
| switch (op) { | |
| case EHTokDot: return EOpIndexDirectStruct; | |
| case EHTokLeftBracket: return EOpIndexIndirect; | |
| case EHTokIncOp: return EOpPostIncrement; | |
| case EHTokDecOp: return EOpPostDecrement; | |
| case EHTokColonColon: return EOpScoping; | |
| default: return EOpNull; // means not a post-unary op | |
| } | |
| } | |
| // Map operators into their level of precedence. | |
| PrecedenceLevel HlslOpMap::precedenceLevel(TOperator op) | |
| { | |
| switch (op) { | |
| case EOpLogicalOr: | |
| return PlLogicalOr; | |
| case EOpLogicalXor: | |
| return PlLogicalXor; | |
| case EOpLogicalAnd: | |
| return PlLogicalAnd; | |
| case EOpInclusiveOr: | |
| return PlBitwiseOr; | |
| case EOpExclusiveOr: | |
| return PlBitwiseXor; | |
| case EOpAnd: | |
| return PlBitwiseAnd; | |
| case EOpEqual: | |
| case EOpNotEqual: | |
| return PlEquality; | |
| case EOpLessThan: | |
| case EOpGreaterThan: | |
| case EOpLessThanEqual: | |
| case EOpGreaterThanEqual: | |
| return PlRelational; | |
| case EOpRightShift: | |
| case EOpLeftShift: | |
| return PlShift; | |
| case EOpAdd: | |
| case EOpSub: | |
| return PlAdd; | |
| case EOpMul: | |
| case EOpDiv: | |
| case EOpMod: | |
| return PlMul; | |
| default: | |
| return PlBad; | |
| } | |
| } | |
| } // end namespace glslang |