コード例 #1
0
        protected internal virtual Value EliminateConstSubExpressions(Private.ConstEvalContext ctx)
        {
            bool has_variable_sub_expression = false;

            for (int i = 0; i < SubExpressions.Length; ++i)
            {
                Value v = TryEliminateConstSubExpressions(ctx, SubExpressions[i]);
                if (v == null)
                {
                    has_variable_sub_expression = true;
                }
                else
                {
                    SubExpressions[i] = v;
                }
            }

            if (has_variable_sub_expression)
            {
                return(null);
            }

            try
            {
                return(Evaluate(ctx));
            }
            catch (Private.ConstEvalContext.NotConstExpression)
            {
                return(null);
            }
        }
コード例 #2
0
            protected internal override Value EliminateConstSubExpressions(Private.ConstEvalContext ctx)
            {
                Value cond_expr = TryEliminateConstSubExpressions(ctx, SubExpressions[0]);

                if (cond_expr == null)
                {
                    Value true_expr = TryEliminateConstSubExpressions(ctx, SubExpressions[1]);
                    if (true_expr != null)
                    {
                        SubExpressions[1] = true_expr;
                    }
                    Value false_expr = TryEliminateConstSubExpressions(ctx, SubExpressions[2]);
                    if (false_expr != null)
                    {
                        SubExpressions[2] = false_expr;
                    }
                    return(null);
                }

                bool cond = cond_expr.ToBool();
                IVariableValueResolver local_ctx = SubExpressions[0].GetLocalContext();

                SubExpressions[0] = new BoolValueWithLocalContext(cond, local_ctx);

                if (local_ctx != null)
                {
                    ctx.PushLocalContext(local_ctx);
                }
                try
                {
                    Value v = TryEliminateConstSubExpressions(ctx, cond ? SubExpressions[1] : SubExpressions[2]);
                    if (v != null)
                    {
                        return(v);
                    }

                    if (cond)
                    {
                        SubExpressions[2] = null;
                    }
                    else
                    {
                        SubExpressions[1] = null;
                    }
                }
                finally
                {
                    if (local_ctx != null)
                    {
                        ctx.PopLocalContext();
                    }
                }

                return(null);
            }
コード例 #3
0
 protected static Value TryEliminateConstSubExpressions(Private.ConstEvalContext ctx, Expression expr)
 {
     try
     {
         return(expr.EliminateConstSubExpressions(ctx));
     }
     catch (Private.ConstEvalContext.NotConstExpression)
     {
         return(null);
     }
 }
コード例 #4
0
 protected sealed internal override Value EliminateConstSubExpressions(Private.ConstEvalContext ctx)
 {
     base.EliminateConstSubExpressions(ctx);
     return(null);
 }