Home | History | Annotate | Download | only in hlsl 
      1 //
      2 // Copyright (C) 2016 Google, Inc.
      3 //
      4 // All rights reserved.
      5 //
      6 // Redistribution and use in source and binary forms, with or without
      7 // modification, are permitted provided that the following conditions
      8 // are met:
      9 //
     10 //    Redistributions of source code must retain the above copyright
     11 //    notice, this list of conditions and the following disclaimer.
     12 //
     13 //    Redistributions in binary form must reproduce the above
     14 //    copyright notice, this list of conditions and the following
     15 //    disclaimer in the documentation and/or other materials provided
     16 //    with the distribution.
     17 //
     18 //    Neither the name of Google, Inc., nor the names of its
     19 //    contributors may be used to endorse or promote products derived
     20 //    from this software without specific prior written permission.
     21 //
     22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
     25 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
     26 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
     27 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
     28 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     29 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
     30 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
     32 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     33 // POSSIBILITY OF SUCH DAMAGE.
     34 //
     35 
     36 // Map from physical token form (e.g. '-') to logical operator
     37 // form (e.g., binary subtract or unary negate).
     38 
     39 #include "hlslOpMap.h"
     40 
     41 namespace glslang {
     42 
     43 // Map parsing tokens that could be assignments into assignment operators.
     44 TOperator HlslOpMap::assignment(EHlslTokenClass op)
     45 {
     46     switch (op) {
     47     case EHTokAssign:      return EOpAssign;
     48     case EHTokMulAssign:   return EOpMulAssign;
     49     case EHTokDivAssign:   return EOpDivAssign;
     50     case EHTokAddAssign:   return EOpAddAssign;
     51     case EHTokModAssign:   return EOpModAssign;
     52     case EHTokLeftAssign:  return EOpLeftShiftAssign;
     53     case EHTokRightAssign: return EOpRightShiftAssign;
     54     case EHTokAndAssign:   return EOpAndAssign;
     55     case EHTokXorAssign:   return EOpExclusiveOrAssign;
     56     case EHTokOrAssign:    return EOpInclusiveOrAssign;
     57     case EHTokSubAssign:   return EOpSubAssign;
     58 
     59     default:
     60         return EOpNull;
     61     }
     62 }
     63 
     64 // Map parsing tokens that could be binary operations into binary operators.
     65 TOperator HlslOpMap::binary(EHlslTokenClass op)
     66 {
     67     switch (op) {
     68     case EHTokPlus:        return EOpAdd;
     69     case EHTokDash:        return EOpSub;
     70     case EHTokStar:        return EOpMul;
     71     case EHTokSlash:       return EOpDiv;
     72     case EHTokPercent:     return EOpMod;
     73     case EHTokRightOp:     return EOpRightShift;
     74     case EHTokLeftOp:      return EOpLeftShift;
     75     case EHTokAmpersand:   return EOpAnd;
     76     case EHTokVerticalBar: return EOpInclusiveOr;
     77     case EHTokCaret:       return EOpExclusiveOr;
     78     case EHTokEqOp:        return EOpEqual;
     79     case EHTokNeOp:        return EOpNotEqual;
     80     case EHTokLeftAngle:   return EOpLessThan;
     81     case EHTokRightAngle:  return EOpGreaterThan;
     82     case EHTokLeOp:        return EOpLessThanEqual;
     83     case EHTokGeOp:        return EOpGreaterThanEqual;
     84     case EHTokOrOp:        return EOpLogicalOr;
     85     case EHTokXorOp:       return EOpLogicalXor;
     86     case EHTokAndOp:       return EOpLogicalAnd;
     87 
     88     default:
     89         return EOpNull;
     90     }
     91 }
     92 
     93 // Map parsing tokens that could be unary operations into unary operators.
     94 // These are just the ones that can appear in front of its operand.
     95 TOperator HlslOpMap::preUnary(EHlslTokenClass op)
     96 {
     97     switch (op) {
     98     case EHTokPlus:       return EOpAdd;        // means no-op, but still a unary op was present
     99     case EHTokDash:       return EOpNegative;
    100     case EHTokBang:       return EOpLogicalNot;
    101     case EHTokTilde:      return EOpBitwiseNot;
    102 
    103     case EHTokIncOp:      return EOpPreIncrement;
    104     case EHTokDecOp:      return EOpPreDecrement;
    105 
    106     default:              return EOpNull;       // means not a pre-unary op
    107     }
    108 }
    109 
    110 // Map parsing tokens that could be unary operations into unary operators.
    111 // These are just the ones that can appear behind its operand.
    112 TOperator HlslOpMap::postUnary(EHlslTokenClass op)
    113 {
    114     switch (op) {
    115     case EHTokDot:         return EOpIndexDirectStruct;
    116     case EHTokLeftBracket: return EOpIndexIndirect;
    117 
    118     case EHTokIncOp:       return EOpPostIncrement;
    119     case EHTokDecOp:       return EOpPostDecrement;
    120 
    121     case EHTokColonColon:  return EOpScoping;
    122 
    123     default:               return EOpNull;             // means not a post-unary op
    124     }
    125 }
    126 
    127 // Map operators into their level of precedence.
    128 PrecedenceLevel HlslOpMap::precedenceLevel(TOperator op)
    129 {
    130     switch (op) {
    131     case EOpLogicalOr:
    132         return PlLogicalOr;
    133     case EOpLogicalXor:
    134         return PlLogicalXor;
    135     case EOpLogicalAnd:
    136         return PlLogicalAnd;
    137 
    138     case EOpInclusiveOr:
    139         return PlBitwiseOr;
    140     case EOpExclusiveOr:
    141         return PlBitwiseXor;
    142     case EOpAnd:
    143         return PlBitwiseAnd;
    144 
    145     case EOpEqual:
    146     case EOpNotEqual:
    147         return PlEquality;
    148 
    149     case EOpLessThan:
    150     case EOpGreaterThan:
    151     case EOpLessThanEqual:
    152     case EOpGreaterThanEqual:
    153         return PlRelational;
    154 
    155     case EOpRightShift:
    156     case EOpLeftShift:
    157         return PlShift;
    158 
    159     case EOpAdd:
    160     case EOpSub:
    161         return PlAdd;
    162 
    163     case EOpMul:
    164     case EOpDiv:
    165     case EOpMod:
    166         return PlMul;
    167 
    168     default:
    169         return PlBad;
    170     }
    171 }
    172 
    173 } // end namespace glslang
    174