xkslang/hlsl/hlslOpMap.cpp

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