Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.facebook.presto.byteCode.expression;
 
 
 import java.util.List;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 
         extends ByteCodeExpression
 {
     {
         checkNotNull(baseOpCode"baseOpCode is null");
         String name = getName(baseOpCode);
         String infixSymbol = getInfixSymbol(baseOpCode);
 
         checkArgumentTypes(baseOpCodenameleftright);
 
         OpCode opCode = getNumericOpCode(namebaseOpCodeleft.getType().getPrimitiveType());
         return new ArithmeticByteCodeExpression(infixSymbolleft.getType(), opCodeleftright);
     }
 
     private static String getName(OpCode baseOpCode)
     {
         switch (baseOpCode) {
             case :
                 return "Bitwise AND";
             case :
                 return "Bitwise OR";
             case :
                 return "Bitwise XOR";
             case :
                 return "Add";
             case :
                 return "Subtract";
             case :
                 return "Multiply";
             case :
                 return "Divide";
             case :
                 return "Remainder";
             case :
                 return "Shift left";
             case :
                 return "Shift right";
             case :
                 return "Shift right unsigned";
             default:
                 throw new IllegalArgumentException("Unsupported OpCode " + baseOpCode);
         }
     }
 
     private static String getInfixSymbol(OpCode baseOpCode)
     {
         switch (baseOpCode) {
             case :
                 return "&";
             case :
                 return "|";
             case :
                 return "^";
             case :
                 return "+";
             case :
                 return "-";
             case :
                 return "*";
             case :
                 return "/";
             case :
                 return "%";
             case :
                 return "<<";
             case :
                 return ">>";
             case :
                 return ">>>";
             default:
                 throw new IllegalArgumentException("Unsupported OpCode " + baseOpCode);
         }
    }
    private static void checkArgumentTypes(OpCode baseOpCodeString nameByteCodeExpression leftByteCodeExpression right)
    {
        Class<?> leftType = getPrimitiveType(left"left");
        Class<?> rightType = getPrimitiveType(right"right");
        switch (baseOpCode) {
            case :
            case :
            case :
                checkArgument(leftType == rightType"left and right must be the same type");
                checkArgument(leftType == int.class || leftType == long.class"%s argument must be int or long, but is %s"nameleftType);
                return;
            case :
            case :
            case :
            case :
            case :
                checkArgument(leftType == rightType"left and right must be the same type");
                checkArgument(leftType == int.class || leftType == long.class || leftType == float.class || leftType == double.class,
                        "%s argument must be int, long, float, or double, but is %s",
                        name,
                        leftType);
                return;
            case :
            case :
            case :
                checkArgument(leftType == int.class || leftType == long.class"%s left argument be int or long, but is %s"nameleftType);
                checkArgument(rightType == int.class"%s right argument be and int, but is %s"namerightType);
                return;
            default:
                throw new IllegalArgumentException("Unsupported OpCode " + baseOpCode);
        }
    }
    static OpCode getNumericOpCode(String nameOpCode baseOpCodeClass<?> type)
    {
        // Arithmetic OpCodes are laid out int, long, float and then double
        if (type == int.class) {
            return baseOpCode;
        }
        else if (type == long.class) {
            return OpCode.getOpCode(baseOpCode.getOpCode() + 1);
        }
        else if (type == float.class) {
            return OpCode.getOpCode(baseOpCode.getOpCode() + 2);
        }
        else if (type == double.class) {
            return OpCode.getOpCode(baseOpCode.getOpCode() + 3);
        }
        else {
            throw new IllegalArgumentException(name + " does not support " + type);
        }
    }
    private static Class<?> getPrimitiveType(ByteCodeExpression expressionString name)
    {
        checkNotNull(expressionname + " is null");
        Class<?> leftType = expression.getType().getPrimitiveType();
        checkArgument(leftType != nullname + " is not a primitive");
        checkArgument(leftType != void.classname + " is void");
        return leftType;
    }
    private final String infixSymbol;
    private final OpCode opCode;
    private final ByteCodeExpression left;
    private final ByteCodeExpression right;
            String infixSymbol,
            ParameterizedType type,
            OpCode opCode,
            ByteCodeExpression left,
            ByteCodeExpression right)
    {
        super(type);
        this. = infixSymbol;
        this. = opCode;
        this. = left;
        this. = right;
    }
    @Override
    public ByteCodeNode getByteCode()
    {
        return new Block(null)
                .append()
                .append()
                .append();
    }
    @Override
    public List<ByteCodeNodegetChildNodes()
    {
        return ImmutableList.<ByteCodeNode>of();
    }
    @Override
    protected String formatOneLine()
    {
        return "(" +  + " " +  + " " +  + ")";
    }
New to GrepCode? Check out our FAQ X