dolphin/Externals/glslang/hlsl/hlslOpMap.cpp

174 lines
5.6 KiB
C++

//
// 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