Ejemplo n.º 1
0
        public override RuntimeValueWrapper Execute(DoExpression e, RuntimeContext context)
        {
            RuntimeValueWrapper result     = null;
            RuntimeContext      newContext = new RuntimeContext()
            {
                PreviousContext = context
            };

            foreach (Expression expression in e.Expressions)
            {
                VarExpression var = expression as VarExpression;
                if (var == null)
                {
                    expression.BuildContext(newContext);
                    result = expression.Execute(newContext);
                }
                else
                {
                    result = new RuntimeValueWrapper(new RuntimeUnevaluatedValue(var.Expression), context);
                    if (!var.Pattern.Match(context, result))
                    {
                        throw new Exception("模式匹配不成功。");
                    }
                }
            }
            if (result == null)
            {
                return(RuntimeValueWrapper.CreateValue(new object()));
            }
            else
            {
                return(result);
            }
        }
Ejemplo n.º 2
0
 public static RuntimeValueWrapper ReturnStateMonadValue(RuntimeValueWrapper[] arguments)
 {
     return(RuntimeValueWrapper.CreateValue(new StatePackage()
     {
         result = arguments[0],
         state = arguments[1]
     }));
 }
Ejemplo n.º 3
0
 public override bool Match(RuntimeContext context, RuntimeValueWrapper valueWrapper)
 {
     if (!valueWrapper.IsInvokable)
     {
         return(Value.Equals(valueWrapper.RuntimeObject));
     }
     return(base.Match(context, valueWrapper));
 }
Ejemplo n.º 4
0
 private void EnsureValueExecuted()
 {
     while (!Value.IsReady)
     {
         RuntimeValueWrapper valueWrapper = Value.Execute(Context);
         Value   = valueWrapper.Value;
         Context = valueWrapper.Context;
     }
 }
Ejemplo n.º 5
0
        public ScriptingValue Invoke(ScriptingValue firstArgument, params ScriptingValue[] arguments)
        {
            RuntimeValueWrapper result = ValueWrapper.Invoke(firstArgument.ValueWrapper);

            foreach (ScriptingValue argument in arguments)
            {
                result = result.Invoke(argument.ValueWrapper);
            }
            return(new ScriptingValue(result));
        }
Ejemplo n.º 6
0
 public override RuntimeValueWrapper Execute(RuntimeContext context)
 {
     return(RuntimeValueWrapper.CreateValue(
                Elements
                .Take(Elements.Count - 1)
                .Select(e => new RuntimeValueWrapper(new RuntimeUnevaluatedValue(e), context))
                .Union((RuntimeValueWrapper[])Elements.Last().Execute(context).RuntimeObject)
                .ToArray()
                ));
 }
Ejemplo n.º 7
0
 public override bool Match(RuntimeContext context, RuntimeValueWrapper valueWrapper)
 {
     if (context.Values.ContainsKey(Name))
     {
         throw new Exception(string.Format("{0}不可重复定义。", Name));
     }
     else
     {
         context.Values.Add(Name, valueWrapper);
         return(true);
     }
 }
Ejemplo n.º 8
0
 public override bool Match(RuntimeContext context, RuntimeValueWrapper valueWrapper)
 {
     if (context.Values.ContainsKey(Name))
     {
         throw new Exception(string.Format("{0}不可重复定义。", Name));
     }
     else if (!valueWrapper.IsInvokable)
     {
         return(new Flag(Name).Equals(valueWrapper.RuntimeObject));
     }
     else
     {
         return(false);
     }
 }
Ejemplo n.º 9
0
        public override RuntimeValueWrapper Execute(RuntimeContext context)
        {
            Monad monad = null;

            if (MonadProvider == null)
            {
                monad = new PureMonad();
            }
            else
            {
                RuntimeValueWrapper monadWrapper = MonadProvider.Execute(context);
                monad = (Monad)monadWrapper.RuntimeObject;
            }
            return(monad.Execute(this, context));
        }
Ejemplo n.º 10
0
        public override RuntimeValueWrapper Execute(RuntimeContext context)
        {
            RuntimeValueWrapper valueToBeMatched = Source.Execute(context);

            foreach (CasePair pair in Pairs)
            {
                RuntimeContext newContext = new RuntimeContext()
                {
                    PreviousContext = context
                };
                if (pair.Pattern.Match(newContext, valueToBeMatched))
                {
                    return(new RuntimeValueWrapper(new RuntimeUnevaluatedValue(pair.Expression), newContext));
                }
            }
            throw new Exception("模式匹配不成功。");
        }
Ejemplo n.º 11
0
        public override RuntimeValueWrapper Execute(DoExpression e, RuntimeContext context)
        {
            Func <RuntimeValueWrapper[], RuntimeValueWrapper> monadFunction = arguments =>
            {
                StatePackage result = new StatePackage()
                {
                    result = null,
                    state  = arguments[0]
                };
                RuntimeContext newContext = new RuntimeContext()
                {
                    PreviousContext = context
                };
                newContext.Values.Add("return", RuntimeValueWrapper.CreateFunction(ReturnStateMonadValue, 2));
                foreach (Expression expression in e.Expressions)
                {
                    VarExpression var = expression as VarExpression;
                    if (var == null)
                    {
                        expression.BuildContext(newContext);
                        result = RunStateMonad(new RuntimeValueWrapper(new RuntimeUnevaluatedValue(expression), newContext), result.state);
                    }
                    else
                    {
                        result = RunStateMonad(new RuntimeValueWrapper(new RuntimeUnevaluatedValue(var.Expression), newContext), result.state);
                        if (!var.Pattern.Match(newContext, result.result))
                        {
                            throw new Exception("模式匹配不成功。");
                        }
                    }
                    if (!(bool)continueFunction.Invoke(result.state).RuntimeObject)
                    {
                        break;
                    }
                }
                if (result.result == null)
                {
                    result.result = RuntimeValueWrapper.CreateValue(new object());
                }
                return(RuntimeValueWrapper.CreateValue(result));
            };

            return(RuntimeValueWrapper.CreateFunction(monadFunction, 1));
        }
Ejemplo n.º 12
0
 public override bool Match(RuntimeContext context, RuntimeValueWrapper valueWrapper)
 {
     if (!valueWrapper.IsInvokable)
     {
         RuntimeValueWrapper[] valueWrappers = valueWrapper.RuntimeObject as RuntimeValueWrapper[];
         if (valueWrappers.Length == Elements.Count)
         {
             for (int i = 0; i < Elements.Count; i++)
             {
                 if (!Elements[i].Match(context, valueWrappers[i]))
                 {
                     return(false);
                 }
             }
             return(true);
         }
     }
     return(base.Match(context, valueWrapper));
 }
Ejemplo n.º 13
0
        public override RuntimeValueWrapper Execute(DoExpression e, RuntimeContext context)
        {
            RuntimeContext newContext = new RuntimeContext()
            {
                PreviousContext = context
            };

            foreach (Expression expression in e.Expressions)
            {
                expression.BuildContext(newContext);
            }
            if (e.Expressions.Count > 0)
            {
                return(new RuntimeValueWrapper(new RuntimeUnevaluatedValue(e.Expressions.Last()), newContext));
            }
            else
            {
                return(RuntimeValueWrapper.CreateValue(new object()));
            }
        }
Ejemplo n.º 14
0
 public override bool Match(RuntimeContext context, RuntimeValueWrapper valueWrapper)
 {
     if (!valueWrapper.IsInvokable)
     {
         RuntimeValueWrapper[] valueWrappers = valueWrapper.RuntimeObject as RuntimeValueWrapper[];
         if (valueWrappers.Length >= Elements.Count - 1)
         {
             for (int i = 0; i < Elements.Count - 1; i++)
             {
                 if (!Elements[i].Match(context, valueWrappers[i]))
                 {
                     return(false);
                 }
             }
             return(Elements[Elements.Count - 1].Match(
                        context,
                        RuntimeValueWrapper.CreateValue(valueWrappers.Skip(Elements.Count - 1).ToArray())
                        ));
         }
     }
     return(base.Match(context, valueWrapper));
 }
Ejemplo n.º 15
0
        public override RuntimeValueWrapper Invoke(RuntimeContext context, RuntimeValueWrapper argument)
        {
            List <IncompletedExpression> newIncompletedExpressions = new List <IncompletedExpression>();

            foreach (IncompletedExpression incompletedExpression in IncompletedExpressions)
            {
                RuntimeContext newContext = new RuntimeContext();
                newContext.PreviousContext = incompletedExpression.Context.PreviousContext;
                foreach (var pair in incompletedExpression.Context.Values)
                {
                    newContext.Values.Add(pair.Key, pair.Value);
                }
                if (incompletedExpression.Patterns.First().Match(newContext, argument))
                {
                    if (incompletedExpression.Patterns.Count == 1)
                    {
                        return(incompletedExpression.Expression.Execute(newContext));
                    }
                    else
                    {
                        IncompletedExpression newIncompletedExpression = new IncompletedExpression();
                        newIncompletedExpression.Context    = newContext;
                        newIncompletedExpression.Expression = incompletedExpression.Expression;
                        newIncompletedExpression.Patterns   = incompletedExpression.Patterns.Skip(1).ToList();
                        newIncompletedExpressions.Add(newIncompletedExpression);
                    }
                }
            }
            if (newIncompletedExpressions.Count == 0)
            {
                throw new Exception("模式匹配不成功。");
            }
            else
            {
                RuntimeInvokableValue value = new RuntimeInvokableValue();
                value.IncompletedExpressions.AddRange(newIncompletedExpressions);
                return(new RuntimeValueWrapper(value, context));
            }
        }
Ejemplo n.º 16
0
        public override void BuildContext(RuntimeContext context)
        {
            RuntimeInvokableValue invokableValue = null;

            if (context.Values.ContainsKey(Name))
            {
                RuntimeValueWrapper valueWrapper = context.Values[Name];
                invokableValue = valueWrapper.Value as RuntimeInvokableValue;
                if (invokableValue == null || this.Patterns.Count == 0)
                {
                    throw new Exception(string.Format("{0}不可重复定义。", Name));
                }
            }
            if (this.Patterns.Count == 0)
            {
                context.Values.Add(Name, new RuntimeValueWrapper(new RuntimeUnevaluatedValue(Expression), context));
            }
            else
            {
                if (invokableValue == null)
                {
                    invokableValue = new RuntimeInvokableValue();
                    context.Values.Add(Name, new RuntimeValueWrapper(invokableValue, context));
                }

                RuntimeInvokableValue.IncompletedExpression incompletedExpression = new RuntimeInvokableValue.IncompletedExpression()
                {
                    Context = new RuntimeContext()
                    {
                        PreviousContext = context
                    },
                    Expression = Expression,
                    Patterns   = new List <Expression>(Patterns),
                };
                invokableValue.IncompletedExpressions.Add(incompletedExpression);
            }
        }
Ejemplo n.º 17
0
 public override RuntimeValueWrapper Invoke(RuntimeContext context, RuntimeValueWrapper argument)
 {
     if (ParameterCount > 0)
     {
         RuntimeValueWrapper[] newArguments = Arguments.Concat(new RuntimeValueWrapper[] { argument }).ToArray();
         if (ParameterCount == 1)
         {
             return(ExternalFunction(newArguments));
         }
         else
         {
             return(new RuntimeValueWrapper(new RuntimeExternalValue()
             {
                 ExternalFunction = ExternalFunction,
                 Arguments = newArguments,
                 ParameterCount = ParameterCount - 1
             }, context));
         }
     }
     else
     {
         throw new Exception("外界函数参数数量不能为0。");
     }
 }
Ejemplo n.º 18
0
 public virtual RuntimeValueWrapper Execute(RuntimeContext context)
 {
     return(RuntimeValueWrapper.CreateValue(new object()));
 }
Ejemplo n.º 19
0
 public override RuntimeValueWrapper Invoke(RuntimeContext context, RuntimeValueWrapper argument)
 {
     throw new NotSupportedException();
 }
Ejemplo n.º 20
0
 public virtual bool Match(RuntimeContext context, RuntimeValueWrapper valueWrapper)
 {
     return(false);
 }
Ejemplo n.º 21
0
 public static StatePackage RunStateMonad(RuntimeValueWrapper monad, RuntimeValueWrapper state)
 {
     return(monad.Invoke(state).RuntimeObject as StatePackage);
 }
Ejemplo n.º 22
0
 public override RuntimeValueWrapper Execute(RuntimeContext context)
 {
     return(RuntimeValueWrapper.CreateValue(new Flag(Name)));
 }
Ejemplo n.º 23
0
 public static ScriptingValue CreateFunction(Func <ScriptingValue[], ScriptingValue> externalFunction, int parameterCount)
 {
     return(new ScriptingValue(RuntimeValueWrapper.CreateFunction(
                                   (xs) => externalFunction(xs.Select(w => new ScriptingValue(w)).ToArray()).ValueWrapper
                                   , parameterCount)));
 }
Ejemplo n.º 24
0
 public RuntimeValueWrapper Invoke(RuntimeValueWrapper argument)
 {
     EnsureValueExecuted();
     return(Value.Invoke(Context, argument));
 }
Ejemplo n.º 25
0
 public override RuntimeValueWrapper Execute(RuntimeContext context)
 {
     return(RuntimeValueWrapper.CreateValue(
                Elements.Select(e => new RuntimeValueWrapper(new RuntimeUnevaluatedValue(e), context)).ToArray()
                ));
 }
Ejemplo n.º 26
0
 public static ScriptingValue CreateValue(object o)
 {
     return(new ScriptingValue(RuntimeValueWrapper.CreateValue(o)));
 }
Ejemplo n.º 27
0
 public static ScriptingValue CreateArray(params object[] o)
 {
     return(new ScriptingValue(RuntimeValueWrapper.CreateArray(o)));
 }
Ejemplo n.º 28
0
 public StateMonad(RuntimeValueWrapper continueFunction)
 {
     this.continueFunction = continueFunction;
 }
Ejemplo n.º 29
0
        public static void LoadLibrary(ScriptingEnvironment e)
        {
            e.DefineValue("pure", ScriptingValue.CreateValue(new PureMonad()));
            e.DefineValue("ordered", ScriptingValue.CreateValue(new OrderedMonad()));
            e.DefineValue("state", ScriptingValue.CreateFunction(State, 1));
            e.DefineValue("continue", ScriptingValue.CreateFunction(Continue, 1));
            e.DefineValue("io", ScriptingValue.CreateFunction(IOContinue, 1));
            e.DefineValue("create_state", new ScriptingValue(RuntimeValueWrapper.CreateFunction(StateMonad.ReturnStateMonadValue, 2)));

            e.DefineValue("(+)", ScriptingValue.CreateFunction(PrimitiveAdd, 2));
            e.DefineValue("(-)", ScriptingValue.CreateFunction(PrimitiveSub, 2));
            e.DefineValue("(*)", ScriptingValue.CreateFunction(PrimitiveMul, 2));
            e.DefineValue("(/)", ScriptingValue.CreateFunction(PrimitiveDiv, 2));
            e.DefineValue("(%)", ScriptingValue.CreateFunction(PrimitiveMod, 2));
            e.DefineValue("(++)", ScriptingValue.CreateFunction(PrimitiveConcat, 2));
            e.DefineValue("(<)", ScriptingValue.CreateFunction(PrimitiveLt, 2));
            e.DefineValue("(<=)", ScriptingValue.CreateFunction(PrimitiveLe, 2));
            e.DefineValue("(>)", ScriptingValue.CreateFunction(PrimitiveGt, 2));
            e.DefineValue("(>=)", ScriptingValue.CreateFunction(PrimitiveGe, 2));
            e.DefineValue("(==)", ScriptingValue.CreateFunction(PrimitiveEq, 2));
            e.DefineValue("(!=)", ScriptingValue.CreateFunction(PrimitiveNe, 2));
            e.DefineValue("(&&)", ScriptingValue.CreateFunction(PrimitiveAnd, 2));
            e.DefineValue("(||)", ScriptingValue.CreateFunction(PrimitiveOr, 2));
            e.DefineValue("(^)", ScriptingValue.CreateFunction(PrimitiveXor, 2));
            e.DefineValue("not", ScriptingValue.CreateFunction(PrimitiveNot, 1));
            e.DefineValue("neg", ScriptingValue.CreateFunction(PrimitiveNeg, 1));
            e.DefineValue("unit", ScriptingValue.CreateFunction(PrimitiveUnit, 1));

            foreach (MethodInfo method in typeof(Math).GetMethods(BindingFlags.Public | BindingFlags.Static))
            {
                if (method.ReturnType == typeof(double) && method.GetParameters().Length > 0 && method.GetParameters().All(p => p.ParameterType == typeof(double)))
                {
                    string methodName = method.Name.ToLower();
                    if (!e.IsDefined(methodName))
                    {
                        e.DefineValue(methodName, ScriptingValue.CreateFunction(MakeDoubleFunction(method), method.GetParameters().Length));
                    }
                }
            }

            e.DefineValue("pi", ScriptingValue.CreateValue(Math.PI));
            e.DefineValue("e", ScriptingValue.CreateValue(Math.E));

            e.DefineValue("aggregate", ScriptingValue.CreateFunction(Aggregate, 3));
            e.DefineValue("distinct", ScriptingValue.CreateFunction(Distinct, 1));
            e.DefineValue("except", ScriptingValue.CreateFunction(Except, 2));
            e.DefineValue("first", ScriptingValue.CreateFunction(First, 2));
            e.DefineValue("intersect", ScriptingValue.CreateFunction(Intersect, 2));
            e.DefineValue("last", ScriptingValue.CreateFunction(Last, 2));
            e.DefineValue("order_by", ScriptingValue.CreateFunction(OrderBy, 2));
            e.DefineValue("reverse", ScriptingValue.CreateFunction(Reverse, 1));
            e.DefineValue("select", ScriptingValue.CreateFunction(Select, 2));
            e.DefineValue("select_many", ScriptingValue.CreateFunction(SelectMany, 2));
            e.DefineValue("skip", ScriptingValue.CreateFunction(Skip, 2));
            e.DefineValue("skip_while", ScriptingValue.CreateFunction(SkipWhile, 2));
            e.DefineValue("take", ScriptingValue.CreateFunction(Take, 2));
            e.DefineValue("take_while", ScriptingValue.CreateFunction(TakeWhile, 2));
            e.DefineValue("union", ScriptingValue.CreateFunction(Union, 2));
            e.DefineValue("where", ScriptingValue.CreateFunction(Where, 2));
            e.DefineValue("zip", ScriptingValue.CreateFunction(Zip, 2));

            e.DefineValue("to_lower", ScriptingValue.CreateFunction(ToLower, 1));
            e.DefineValue("to_upper", ScriptingValue.CreateFunction(ToUpper, 1));
            e.DefineValue("find", ScriptingValue.CreateFunction(Find, 2));
            e.DefineValue("find_all", ScriptingValue.CreateFunction(FindAll, 2));
            e.DefineValue("reg_find", ScriptingValue.CreateFunction(RegFind, 2));
            e.DefineValue("reg_find_all", ScriptingValue.CreateFunction(RegFindAll, 2));
            e.DefineValue("length", ScriptingValue.CreateFunction(Length, 1));
            e.DefineValue("item", ScriptingValue.CreateFunction(Item, 2));
            e.DefineValue("empty", ScriptingValue.CreateFunction(Empty, 1));
            e.DefineValue("split", ScriptingValue.CreateFunction(Split, 2));

            e.DefineValue("to_int", ScriptingValue.CreateFunction(ToInt, 1));
            e.DefineValue("to_double", ScriptingValue.CreateFunction(ToDouble, 1));
            e.DefineValue("to_string", ScriptingValue.CreateFunction(ToString, 1));

            e.DefineValue("read_file", ScriptingValue.CreateFunction(ReadFile, 1));
            e.DefineValue("write_file", ScriptingValue.CreateFunction(WriteFile, 2));
        }
Ejemplo n.º 30
0
 internal ScriptingValue(RuntimeValueWrapper valueWrapper)
 {
     this.ValueWrapper = valueWrapper;
 }