CompileBinaryExpression()

void System.Linq.Expressions.Interpreter.LightCompiler.CompileBinaryExpression ( Expression expr )

inlineprivate

Definition at line 517 of file LightCompiler.cs.

    {
        BinaryExpression binaryExpression = (BinaryExpression)expr;
        if (binaryExpression.Method != null)
        {
            if (binaryExpression.IsLifted)
            {
                BranchLabel label = _instructions.MakeLabel();
                LocalDefinition definition = _locals.DefineLocal(Expression.Parameter(binaryExpression.Left.Type), _instructions.Count);
                Compile(binaryExpression.Left);
                _instructions.EmitStoreLocal(definition.Index);
                LocalDefinition definition2 = _locals.DefineLocal(Expression.Parameter(binaryExpression.Right.Type), _instructions.Count);
                Compile(binaryExpression.Right);
                _instructions.EmitStoreLocal(definition2.Index);
                ExpressionType nodeType = binaryExpression.NodeType;
                if ((nodeType == ExpressionType.Equal || nodeType == ExpressionType.NotEqual) && !binaryExpression.IsLiftedToNull)
                {
                    BranchLabel branchLabel = _instructions.MakeLabel();
                    BranchLabel branchLabel2 = _instructions.MakeLabel();
                    _instructions.EmitLoadLocal(definition.Index);
                    _instructions.EmitLoad(null, typeof(object));
                    _instructions.EmitEqual(typeof(object));
                    _instructions.EmitBranchFalse(branchLabel);
                    _instructions.EmitLoadLocal(definition2.Index);
                    _instructions.EmitLoad(null, typeof(object));
                    if (binaryExpression.NodeType == ExpressionType.Equal)
                    {
                        _instructions.EmitEqual(typeof(object));
                    }
                    else
                    {
                        _instructions.EmitNotEqual(typeof(object));
                    }
                    _instructions.EmitBranch(label, hasResult: false, hasValue: true);
                    _instructions.MarkLabel(branchLabel);
                    _instructions.EmitLoadLocal(definition2.Index);
                    _instructions.EmitLoad(null, typeof(object));
                    _instructions.EmitEqual(typeof(object));
                    _instructions.EmitBranchFalse(branchLabel2);
                    _instructions.EmitLoad((binaryExpression.NodeType == ExpressionType.Equal) ? Utils.BoxedFalse : Utils.BoxedTrue, typeof(bool));
                    _instructions.EmitBranch(label, hasResult: false, hasValue: true);
                    _instructions.MarkLabel(branchLabel2);
                    _instructions.EmitLoadLocal(definition.Index);
                    _instructions.EmitLoadLocal(definition2.Index);
                    _instructions.EmitCall(binaryExpression.Method);
                }
                else
                {
                    BranchLabel branchLabel3 = _instructions.MakeLabel();
                    if (binaryExpression.Left.Type.IsNullableOrReferenceType())
                    {
                        _instructions.EmitLoadLocal(definition.Index);
                        _instructions.EmitLoad(null, typeof(object));
                        _instructions.EmitEqual(typeof(object));
                        _instructions.EmitBranchTrue(branchLabel3);
                    }
                    if (binaryExpression.Right.Type.IsNullableOrReferenceType())
                    {
                        _instructions.EmitLoadLocal(definition2.Index);
                        _instructions.EmitLoad(null, typeof(object));
                        _instructions.EmitEqual(typeof(object));
                        _instructions.EmitBranchTrue(branchLabel3);
                    }
                    _instructions.EmitLoadLocal(definition.Index);
                    _instructions.EmitLoadLocal(definition2.Index);
                    _instructions.EmitCall(binaryExpression.Method);
                    _instructions.EmitBranch(label, hasResult: false, hasValue: true);
                    _instructions.MarkLabel(branchLabel3);
                    ExpressionType nodeType2 = binaryExpression.NodeType;
                    if (((uint)(nodeType2 - 15) <= 1u || (uint)(nodeType2 - 20) <= 1u) && !binaryExpression.IsLiftedToNull)
                    {
                        _instructions.EmitLoad(Utils.BoxedFalse, typeof(object));
                    }
                    else
                    {
                        _instructions.EmitLoad(null, typeof(object));
                    }
                }
                _instructions.MarkLabel(label);
                _locals.UndefineLocal(definition, _instructions.Count);
                _locals.UndefineLocal(definition2, _instructions.Count);
            }
            else
            {
                Compile(binaryExpression.Left);
                Compile(binaryExpression.Right);
                _instructions.EmitCall(binaryExpression.Method);
            }
        }
        else
        {
            switch (binaryExpression.NodeType)
            {
            case ExpressionType.ArrayIndex:
                Compile(binaryExpression.Left);
                Compile(binaryExpression.Right);
                _instructions.EmitGetArrayItem();
                break;
            case ExpressionType.Add:
            case ExpressionType.AddChecked:
            case ExpressionType.Divide:
            case ExpressionType.Modulo:
            case ExpressionType.Multiply:
            case ExpressionType.MultiplyChecked:
            case ExpressionType.Subtract:
            case ExpressionType.SubtractChecked:
                CompileArithmetic(binaryExpression.NodeType, binaryExpression.Left, binaryExpression.Right);
                break;
            case ExpressionType.ExclusiveOr:
                Compile(binaryExpression.Left);
                Compile(binaryExpression.Right);
                _instructions.EmitExclusiveOr(binaryExpression.Left.Type);
                break;
            case ExpressionType.Or:
                Compile(binaryExpression.Left);
                Compile(binaryExpression.Right);
                _instructions.EmitOr(binaryExpression.Left.Type);
                break;
            case ExpressionType.And:
                Compile(binaryExpression.Left);
                Compile(binaryExpression.Right);
                _instructions.EmitAnd(binaryExpression.Left.Type);
                break;
            case ExpressionType.Equal:
                CompileEqual(binaryExpression.Left, binaryExpression.Right, binaryExpression.IsLiftedToNull);
                break;
            case ExpressionType.NotEqual:
                CompileNotEqual(binaryExpression.Left, binaryExpression.Right, binaryExpression.IsLiftedToNull);
                break;
            case ExpressionType.GreaterThan:
            case ExpressionType.GreaterThanOrEqual:
            case ExpressionType.LessThan:
            case ExpressionType.LessThanOrEqual:
                CompileComparison(binaryExpression);
                break;
            case ExpressionType.LeftShift:
                Compile(binaryExpression.Left);
                Compile(binaryExpression.Right);
                _instructions.EmitLeftShift(binaryExpression.Left.Type);
                break;
            case ExpressionType.RightShift:
                Compile(binaryExpression.Left);
                Compile(binaryExpression.Right);
                _instructions.EmitRightShift(binaryExpression.Left.Type);
                break;
            default:
                throw new PlatformNotSupportedException(System.SR.Format(System.SR.UnsupportedExpressionType, binaryExpression.NodeType));
            }
        }
    }

References System.Linq.Expressions.Interpreter.LightCompiler._instructions, System.Linq.Expressions.Interpreter.LightCompiler._locals, System.Collections.Generic.Dictionary< TKey, TValue >.Add(), System.Linq.Expressions.Utils.BoxedFalse, System.Linq.Expressions.Utils.BoxedTrue, System.Linq.Expressions.Interpreter.LightCompiler.Compile(), System.Linq.Expressions.Interpreter.LightCompiler.CompileArithmetic(), System.Linq.Expressions.Interpreter.LightCompiler.CompileComparison(), System.Linq.Expressions.Interpreter.LightCompiler.CompileEqual(), System.Linq.Expressions.Interpreter.LightCompiler.CompileNotEqual(), System.Linq.Expressions.Interpreter.InstructionList.Count, System.Linq.Expressions.Interpreter.LocalVariables.DefineLocal(), System.Linq.Expressions.Interpreter.InstructionList.EmitAnd(), System.Linq.Expressions.Interpreter.InstructionList.EmitBranch(), System.Linq.Expressions.Interpreter.InstructionList.EmitBranchFalse(), System.Linq.Expressions.Interpreter.InstructionList.EmitBranchTrue(), System.Linq.Expressions.Interpreter.InstructionList.EmitCall(), System.Linq.Expressions.Interpreter.InstructionList.EmitEqual(), System.Linq.Expressions.Interpreter.InstructionList.EmitExclusiveOr(), System.Linq.Expressions.Interpreter.InstructionList.EmitGetArrayItem(), System.Linq.Expressions.Interpreter.InstructionList.EmitLeftShift(), System.Linq.Expressions.Interpreter.InstructionList.EmitLoad(), System.Linq.Expressions.Interpreter.InstructionList.EmitLoadLocal(), System.Linq.Expressions.Interpreter.InstructionList.EmitNotEqual(), System.Linq.Expressions.Interpreter.InstructionList.EmitOr(), System.Linq.Expressions.Interpreter.InstructionList.EmitRightShift(), System.Linq.Expressions.Interpreter.InstructionList.EmitStoreLocal(), System.SR.Format(), System.Linq.Expressions.Interpreter.InstructionList.MakeLabel(), System.Linq.Expressions.Interpreter.InstructionList.MarkLabel(), System.Linq.Expressions.Expression< TDelegate >.Parameter(), System.Linq.Expressions.Interpreter.LocalVariables.UndefineLocal(), and System.SR.UnsupportedExpressionType.

Referenced by System.Linq.Expressions.Interpreter.LightCompiler.CompileNoLabelPush().