Exemple #1
0
        private static Expression CreateVariableExpressions(
            IList <Expression> expressions,
            VaribalesCollection variables,
            NodeCollection nodes,
            Expression ifNull)
        {
            var source = CreateVariableInnerExpressions(expressions, variables, nodes, ifNull);

            if (nodes.Count == 1)
            {
                return(source);
            }

            var target = Expression.Variable(nodes.First().Type, $"value{variables.GetNextIndex()}");

            variables.Add(target);
            InsertExpression(expressions, variables, source, nodes.First(), ifNull, target);
            return(target);
        }
Exemple #2
0
        private static Expression CreateVariableInnerExpressions(
            IList <Expression> expressions,
            VaribalesCollection variables,
            NodeCollection nodes,
            Expression ifNull)
        {
            var list = nodes.ToList();

            list.Reverse();
            var        i = 1;
            Expression target;
            var        element = list.First();
            {
                switch (element)
                {
                case ParameterNode parameter:
                {
                    var p = parameter.Expression;
                    target = p;
                    ParameterNextParameter(expressions, target, parameter, ifNull);
                    break;
                }

                case ConstantNode constant:
                    target = constant.Expression;
                    break;

                case MethodNode method:
                {
                    var p = Expression.Variable(method.Type, $"value{variables.GetNextIndex()}");
                    target = p;
                    variables.Add(p);
                    MethodNextElement(expressions, variables, target, method, ifNull);
                    break;
                }

                case ConstructorNode constructor:
                {
                    var p = Expression.Variable(constructor.Type, $"value{variables.GetNextIndex()}");
                    target = p;
                    variables.Add(p);
                    ConstructorNextElement(expressions, variables, target, constructor, ifNull);
                    break;
                }

                case FunctionNode function:
                {
                    var p = Expression.Variable(function.Type, $"value{variables.GetNextIndex()}");
                    target = p;
                    variables.Add(p);
                    FunctionNextElement(expressions, variables, target, function, ifNull);
                    break;
                }

                case BinaryNode binary:
                {
                    var p = Expression.Variable(binary.Type, $"value{variables.GetNextIndex()}");
                    target = p;
                    variables.Add(p);
                    BinaryNextElement(expressions, variables, target, binary, ifNull);
                    break;
                }

                case UnaryNode unary:
                {
                    var p = Expression.Variable(unary.Type, $"value{variables.GetNextIndex()}");
                    target = p;
                    variables.Add(p);
                    UnaryNextElement(expressions, variables, target, unary, ifNull);
                    break;
                }

                case ConditionalNode conditional:
                {
                    var p = Expression.Variable(conditional.Type, $"value{variables.GetNextIndex()}");
                    target = p;
                    variables.Add(p);
                    ConditionalNextElement(expressions, variables, target, conditional, ifNull);
                    break;
                }

                case MemberInitNode memberInit:
                {
                    var p = Expression.Variable(memberInit.Type, $"value{variables.GetNextIndex()}");
                    target = p;
                    variables.Add(p);
                    MemberInitNextElement(expressions, variables, target, memberInit, ifNull);
                    break;
                }

                default:
                {
                    throw new ArgumentOutOfRangeException($"{element}");
                }
                }
            }

            var count = list.Count;

            if (count == 1)
            {
                return(target);
            }

            var source = target;

            for (; i < count - 1; i++)
            {
                element = list[i];
                var p = Expression.Variable(element.Type, $"value{variables.GetNextIndex()}");
                variables.Add(p);
                target = p;
                InsertExpression(expressions, variables, source, element, ifNull, p);
                source = target;
            }

            return(target);
        }