◆ EmitExpression() [2/2]

void System.Linq.Expressions.Compiler.LambdaCompiler.EmitExpression	(	Expression	node,
		CompilationFlags	flags )
inlineprivate
Definition at line 2098 of file LambdaCompiler.cs.
    {
        if (!_guard.TryEnterOnCurrentStack())
        {
            _guard.RunOnEmptyStack(delegate(LambdaCompiler @this, Expression n, CompilationFlags f)
            {
                @this.EmitExpression(n, f);
            }, this, node, flags);
            return;
        }
        bool flag = (flags & CompilationFlags.EmitExpressionStartMask) == CompilationFlags.EmitExpressionStart;
        CompilationFlags flags2 = (flag ? EmitExpressionStart(node) : CompilationFlags.EmitNoExpressionStart);
        flags &= CompilationFlags.EmitAsTailCallMask;
        switch (node.NodeType)
        {
        case ExpressionType.Add:
        case ExpressionType.AddChecked:
        case ExpressionType.And:
        case ExpressionType.ArrayIndex:
        case ExpressionType.Divide:
        case ExpressionType.Equal:
        case ExpressionType.ExclusiveOr:
        case ExpressionType.GreaterThan:
        case ExpressionType.GreaterThanOrEqual:
        case ExpressionType.LeftShift:
        case ExpressionType.LessThan:
        case ExpressionType.LessThanOrEqual:
        case ExpressionType.Modulo:
        case ExpressionType.Multiply:
        case ExpressionType.MultiplyChecked:
        case ExpressionType.NotEqual:
        case ExpressionType.Or:
        case ExpressionType.Power:
        case ExpressionType.RightShift:
        case ExpressionType.Subtract:
        case ExpressionType.SubtractChecked:
            EmitBinaryExpression(node, flags);
            break;
        case ExpressionType.AndAlso:
            EmitAndAlsoBinaryExpression(node, flags);
            break;
        case ExpressionType.OrElse:
            EmitOrElseBinaryExpression(node, flags);
            break;
        case ExpressionType.Coalesce:
            EmitCoalesceBinaryExpression(node);
            break;
        case ExpressionType.Assign:
            EmitAssignBinaryExpression(node);
            break;
        case ExpressionType.ArrayLength:
        case ExpressionType.Negate:
        case ExpressionType.UnaryPlus:
        case ExpressionType.NegateChecked:
        case ExpressionType.Not:
        case ExpressionType.TypeAs:
        case ExpressionType.Decrement:
        case ExpressionType.Increment:
        case ExpressionType.OnesComplement:
        case ExpressionType.IsTrue:
        case ExpressionType.IsFalse:
            EmitUnaryExpression(node, flags);
            break;
        case ExpressionType.Convert:
        case ExpressionType.ConvertChecked:
            EmitConvertUnaryExpression(node, flags);
            break;
        case ExpressionType.Quote:
            EmitQuoteUnaryExpression(node);
            break;
        case ExpressionType.Throw:
            EmitThrowUnaryExpression(node);
            break;
        case ExpressionType.Unbox:
            EmitUnboxUnaryExpression(node);
            break;
        case ExpressionType.Call:
            EmitMethodCallExpression(node, flags);
            break;
        case ExpressionType.Conditional:
            EmitConditionalExpression(node, flags);
            break;
        case ExpressionType.Constant:
            EmitConstantExpression(node);
            break;
        case ExpressionType.Invoke:
            EmitInvocationExpression(node, flags);
            break;
        case ExpressionType.Lambda:
            EmitLambdaExpression(node);
            break;
        case ExpressionType.ListInit:
            EmitListInitExpression(node);
            break;
        case ExpressionType.MemberAccess:
            EmitMemberExpression(node);
            break;
        case ExpressionType.MemberInit:
            EmitMemberInitExpression(node);
            break;
        case ExpressionType.New:
            EmitNewExpression(node);
            break;
        case ExpressionType.NewArrayInit:
        case ExpressionType.NewArrayBounds:
            EmitNewArrayExpression(node);
            break;
        case ExpressionType.Parameter:
            EmitParameterExpression(node);
            break;
        case ExpressionType.TypeIs:
        case ExpressionType.TypeEqual:
            EmitTypeBinaryExpression(node);
            break;
        case ExpressionType.Block:
            EmitBlockExpression(node, flags);
            break;
        case ExpressionType.DebugInfo:
            EmitDebugInfoExpression(node);
            break;
        case ExpressionType.Dynamic:
            EmitDynamicExpression(node);
            break;
        case ExpressionType.Default:
            EmitDefaultExpression(node);
            break;
        case ExpressionType.Goto:
            EmitGotoExpression(node, flags);
            break;
        case ExpressionType.Index:
            EmitIndexExpression(node);
            break;
        case ExpressionType.Label:
            EmitLabelExpression(node, flags);
            break;
        case ExpressionType.RuntimeVariables:
            EmitRuntimeVariablesExpression(node);
            break;
        case ExpressionType.Loop:
            EmitLoopExpression(node);
            break;
        case ExpressionType.Switch:
            EmitSwitchExpression(node, flags);
            break;
        case ExpressionType.Try:
            EmitTryExpression(node);
            break;
        }
        if (flag)
        {
            EmitExpressionEnd(flags2);
        }
    }