Esempio n. 1
0
        private Expression CompileVariableContextExpression(int lambdaLevel)
        {
            PushPosition();

            List <VariableInfo> variables = new List <VariableInfo>();

            while (!IsPunctuationOf("->"))
            {
                string variableName = GetWord();
                Move();


                Type clazz = null;

                if (IsPunctuationOf(":"))
                {
                    SkipPunctuation(":");

                    string className = ReadClassName();
                    try
                    {
                        clazz = Types.GetType(className, LanguageService.GetImportedPackages());
                    }
                    catch
                    {
                        ThrowException(string.Format("{0} not defined.", className));
                    }
                }
                else
                {
                    clazz = typeof(double);
                }

                variables.Add(new VariableInfo()
                {
                    Name = variableName, Type = clazz
                });


                if (IsPunctuationOf(","))
                {
                    Move();
                }
            }


            Move();

            Expression expression = Compile(lambdaLevel);

            VariableContextExpression result = new VariableContextExpression(expression, variables.ToArray(), PeekPos(), Pos);

            PopPosition();


            return(result);
        }
Esempio n. 2
0
        private void CheckVariableContextExpression(VariableContextExpression e, TypeCheckingContext context)
        {
            foreach (VariableInfo variable in e.Variables)
            {
                context.VariableContext.Set(variable.Name, context.CreateAutoCreatedVariableValue(variable.Type));
            }


            PerformTypeChecking(e.Expression, context);

            foreach (VariableInfo variable in e.Variables)
            {
                context.VariableContext.Remove(variable.Name);
            }


            e.Type      = typeof(VariableContextExpression);
            e.Evaluator = new MathyExpressionEvaluator();
        }
 private object EvaluateVariableContextExpression(VariableContextExpression e, VariableContext context)
 {
     e.VariableContext = context;
     return(e);
 }