Example #1
0
        public static Expression GetExpression(Variable variable, IDictionary <string, Expression> valuePairs, IDictionary <string, object> datas)
        {
            if (variable.Type == VariableType.StaticMethod)
            {
                InvokeVariable invokeVariable = (InvokeVariable)variable;
                return(BuildRealParam(invokeVariable, valuePairs, datas, null, invokeVariable.Path));
            }

            Expression    expression;
            ConstVariable constVariable = (ConstVariable)variable;

            if (!valuePairs.TryGetValue(constVariable.Name, out expression))
            {
                if (constVariable.IsParamer == false)
                {
                    expression = Expression.Constant(constVariable.GetValue(datas));
                }
                else
                {
                    expression = Expression.Parameter(constVariable.ValType, constVariable.Name);
                }

                valuePairs.Add(constVariable.Name, expression);
            }

            if (!constVariable.NotSelf)
            {
                return(expression);
            }

            return(BuildRealParam(constVariable, valuePairs, datas, expression, constVariable.Path));
        }
Example #2
0
        public static Expression BuildRealParam(InvokeVariable variable, IDictionary <string, Expression> valuePairs, IDictionary <string, object> datas, Expression expression, string path, int start = 0)
        {
            var    index = path.IndexOfAny(new char[] { Strings.Split, char.Parse(Strings.StartFlag1) }, start);
            string val   = string.Empty;

            if (index < 0)
            {
                val = path.Substring(start);
                return(CallProperty(variable, expression, val));
            }

            val = path.Substring(start, index - start);
            if (path[index] == Strings.Split)
            {
                expression = CallProperty(variable, expression, val);
            }
            else
            {
                return(CallMethod(variable, valuePairs, datas, expression, val));
            }

            if (index > -1)
            {
                return(BuildRealParam(variable, valuePairs, datas, expression, path, index + 1));
            }

            return(expression);
        }
Example #3
0
        public static Expression CallProperty(InvokeVariable variable, Expression expression, string propertyName)
        {
            if (variable.Type == VariableType.Const)
            {
                return(Expression.PropertyOrField(expression, propertyName));
            }

            return(Expression.Field(null, ((StaticMethodVariable)variable).InstanceType, propertyName));
        }
Example #4
0
        public static Expression CallMethod(InvokeVariable variable, IDictionary <string, Expression> valuePairs, IDictionary <string, object> datas, Expression expression, string methodName)
        {
            var               varParams        = variable.Params;
            MethodInfo        methodInfo       = null;
            List <Expression> paramExpressions = new List <Expression>();

            Type[] types;
            if (varParams != null)
            {
                foreach (var param in varParams)
                {
                    var fisrtParam = param.First();
                    if (param.Count() == 1)
                    {
                        paramExpressions.Add(GetExpression(fisrtParam, valuePairs, datas));
                    }
                    else
                    {
                        var expressions = Util.BuildExpression(param, valuePairs, datas);
                        paramExpressions.Add(expressions.First());
                    }
                }

                types = paramExpressions.Select(t => t.Type).ToArray();
            }
            else
            {
                types = new Type[] { };
            }

            if (variable.Type == VariableType.Const)
            {
                methodInfo = expression.Type.GetMethod(methodName, types);
            }
            else
            {
                methodInfo = ((StaticMethodVariable)variable).InstanceType.GetMethod(methodName, types);
            }

            return(Expression.Call(expression, methodInfo, paramExpressions.ToArray()));
        }
Example #5
0
        public static void SetInvokeParam(IEnumerable <Token> tokens, InvokeVariable variable, string flag, int i)
        {
            Token nextToken = null;

            if (tokens.Count() > (i + 1))
            {
                nextToken = tokens.ElementAt(i + 1);
            }

            if (nextToken == null || nextToken.Flag != Strings.StartFlag1)
            {
                variable.Path = variable.Value.Remove(0, variable.Name.Count() + 1);
                return;
            }

            var result = GetParamVariables(tokens, flag, i);

            variable.Params          = result.Item1;
            variable.Value           = string.Concat(flag, Strings.StartFlag1, string.Join(string.Empty, result.Item2.Select(t => t.Flag)), Strings.EndFlag1);
            variable.Path            = variable.Value.Remove(0, variable.Name.Count() + 1);
            variable.ParamTokenCount = result.Item2.Count() + 2;
        }