Revision control
++ //
++ // 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