protected override Completion ExecuteImpl(ExecutionEnvironment enviroment) { if (Variable == null) { return(Completion.Exception(Properties.Language.VariableNameException, this)); } if (!(Variable is Identifier)) { return(Completion.Exception(Properties.Language.OnlyVariableAccept, Variable)); } string name = (Variable as Identifier).Variable; if (Value == null) { enviroment.RegisterValue(name, null); return(Completion.Void); } else { var c = Value.Execute(enviroment); if (!c.IsValue) { return(c); } enviroment.RegisterValue(name, c.ReturnValue); return(c); } }
public Completion Execute(ExecutionEnvironment enviroment) { if (Expression == null) { return(new Completion(null)); } return(Expression.Execute(enviroment)); }
protected override Completion ExecuteImpl(ExecutionEnvironment enviroment) { if (Expression == null) { return(Completion.Void); } return(Expression.Execute(enviroment)); }
public Completion Execute(ExecutionEnvironment enviroment) { if (Min == null) { return(Completion.Exception("parameter of random can not be null", Min)); } if (Max == null) { return(Completion.Exception("parameter of random can not be null", Max)); } var left = Min.Execute(enviroment); if (left.Type != CompletionType.Value) { return(left); } var right = Max.Execute(enviroment); if (right.Type != CompletionType.Value) { return(right); } if (right.Type != CompletionType.Value) { return(right); } if (!TypeConverters.IsNumber(left.ReturnValue)) { return(Completion.Exception("value is not a number", Min)); } if (!TypeConverters.IsNumber(right.ReturnValue)) { return(Completion.Exception("value is not a number", Max)); } Type T = TypeConverters.GetNumberTypes(left.ReturnValue, right.ReturnValue); if (T == null) { return(Completion.Exception("Only nuber can accepted", this)); } try { var l = TypeConverters.GetValue <int>(left.ReturnValue); var r = TypeConverters.GetValue <int>(right.ReturnValue); return(new Completion(new Random(1437).Next(l, r))); } catch (Exception e) { return(Completion.Exception(e.Message, this)); } }
public Completion Execute(ExecutionEnvironment enviroment) { ExecutionEnvironment current = new ExecutionEnvironment(); foreach (var f in enviroment.Module.Functions) { if (Function.Equals(f.Name)) { for (int i = 0; i < Args.Count; i++) { Expression e = Args[i]; string name = ArgTyps[i]; Completion cp = e.Execute(enviroment); if (cp.Type != CompletionType.Value) { return(cp); } current.RegisterValue(f.Params[i].Name, cp.ReturnValue); } var c = f.Execute(current); return(c); } } DelegateFunction func = enviroment.GetFunction(Function); List <object> parameters = new List <object>(); if (func != null) { try { for (int i = 0; i < Args.Count; i++) { Expression e = Args[i]; string name = ArgTyps[i]; Completion cp = e.Execute(enviroment); if (cp.Type != CompletionType.Value) { return(cp); } parameters.Add(cp.ReturnValue); } return(new Completion(func.Invoke(parameters.ToArray()))); } catch (Exception e) { return(Completion.Exception(e.Message, this)); } } return(Completion.Void); }
protected override Completion ExecuteImpl(ExecutionEnvironment enviroment) { if (Expression == null) { return(new Completion(null, CompletionType.Return)); } var c = Expression.Execute(enviroment); if (c.Type == CompletionType.Value) { return(new Completion(c.ReturnValue, CompletionType.Return)); } return(c); }
protected override Completion ExecuteImpl(ExecutionEnvironment enviroment) { if (Expression == null) { return(Completion.Exception(Properties.Language.NullException, this)); } var c = Expression.Execute(enviroment); if (c.Type != CompletionType.Value) { return(c); } if (!TypeConverters.IsNumber(c.ReturnValue)) { return(Completion.Exception(Properties.Language.NotNumber, Expression)); } Type t = c.ReturnValue.GetType(); if (t.Equals(typeof(int))) { int v = TypeConverters.GetValue <int>(c.ReturnValue); int old = v; if (Operator == UpdateOperator.Add) { v += 1; } else { v = v - 1; } if (Expression is Identifier) { enviroment.SetValue(((Identifier)Expression).Variable, v); } return(new Completion(IsPrefix ? v : old)); } else if (t.Equals(typeof(float))) { float v = TypeConverters.GetValue <float>(c.ReturnValue); float old = v; if (Operator == UpdateOperator.Add) { v += 1; } else { v = v - 1; } if (Expression is Identifier) { enviroment.SetValue(((Identifier)Expression).Variable, v); } return(new Completion(IsPrefix ? v : old)); } else { double v = TypeConverters.GetValue <double>(c.ReturnValue); double old = v; if (Operator == UpdateOperator.Add) { v += 1; } else { v = v - 1; } if (Expression is Identifier) { enviroment.SetValue(((Identifier)Expression).Variable, v); } return(new Completion(IsPrefix ? v : old)); } }
protected override Completion ExecuteImpl(ExecutionEnvironment enviroment) { /* * if (DelegateFunction != null) * { * List<object> ps = new List<object>(); * for (int i = 0; i < Args.Count; i++) * { * Expression e = Args[i]; * string name = ArgTyps[i]; * * Completion cp = e.Execute(enviroment); * if (cp.Type != CompletionType.Value) * return cp; * ps.Add(cp.ReturnValue); * } * DelegateFunction.Invoke(ps.ToArray()); * return Completion.Void; * }*/ foreach (var f in enviroment.Module.Functions) { if (Function.Equals(f.Name)) { ExecutionEnvironment current = new ExecutionEnvironment(enviroment.GetInstanceEnvironment()); for (int i = 0; i < Args.Count; i++) { Expression e = Args[i]; string name = ArgTyps[i]; Completion cp = e.Execute(enviroment); if (cp.Type != CompletionType.Value) { return(cp); } current.RegisterValue(f.Params[i].Name, cp.ReturnValue); } var c = f.Execute(current); return(c); } } DelegateFunction func = enviroment.GetFunction(Function); List <object> parameters = new List <object>(); if (func != null) { try { for (int i = 0; i < Args.Count; i++) { Expression e = Args[i]; string name = ArgTyps[i]; if (e == null) { return(Completion.Exception(Properties.Language.ParameterNullException, this)); } Completion cp = e.Execute(enviroment); if (cp.Type != CompletionType.Value) { return(cp); } parameters.Add(cp.ReturnValue); } return(new Completion(func.Invoke(parameters.ToArray()))); } catch (Exception e) { return(Completion.Exception(e.Message, this)); } } return(Completion.Void); }
public Completion Execute(Class m) { IsAborting = false; IsCompleted = false; _current = m; if (_current == null) { return(null); } Completion c = Completion.Void; ExecutionEnvironment baseEnv = this.GetBaseEnvironment(); ExecutionEnvironment classEnv = new ExecutionEnvironment(baseEnv); ExecutionEnvironment instanceEnv = new ExecutionEnvironment(classEnv); foreach (var v in m.Variables) { instanceEnv.RegisterValue(v.Name, v.Value); } foreach (var func in _current.Functions) { if ("main".Equals(func.Name, StringComparison.OrdinalIgnoreCase)) { var parameter = func.Params; ExecutionEnvironment functionEnv = new ExecutionEnvironment(instanceEnv); ExecutionStarted?.Invoke(this, null); foreach (var p in parameter) { functionEnv.RegisterValue(p.Name, null); } foreach (var block in m.BlockStatements) { foreach (var s in block.Body) { if (s is ExpressionStatement) { Expression exp = (s as ExpressionStatement).Expression; if (exp is VariableDeclarationExpression) { exp.Execute(instanceEnv); } } } } try { IsCompleted = false; c = func.Execute(functionEnv); break; }catch (Exception e) { IsCompleted = true; Console.WriteLine(e.Message); Console.WriteLine(e.StackTrace); ExecutionAborted?.Invoke(this, new Completion(e.Message, CompletionType.Exception)); return(Completion.Void); } } } IsCompleted = true; if (c.Type == CompletionType.Value) { ExecutionCompleted?.Invoke(this, c); } else if (c.Type == CompletionType.Exception) { ExecutionAborted?.Invoke(this, c); } else { ExecutionAborted?.Invoke(this, Completion.Exception(Properties.Language.UnknowException, null)); } return(c); }