public override Expression Call(Expression expr) { var currentProcess = Process.GetCurrentProcess(); TimeSpan _userProcessorTimeStart; TimeSpan _userProcessorTimeEnd; TimeSpan _privilegedProcessorTimeStart; TimeSpan _privilegedProcessorTimeEnd; /* RECORD START TIME */ Stopwatch _stopwatch = Stopwatch.StartNew(); _userProcessorTimeStart = currentProcess.UserProcessorTime; _privilegedProcessorTimeStart = currentProcess.PrivilegedProcessorTime; /* DO THE ACTUAL OPERATION */ var result = Evaluate(expr.Elements.Second()); /* RECORD STOP TIME */ _userProcessorTimeEnd = currentProcess.UserProcessorTime; _privilegedProcessorTimeEnd = currentProcess.PrivilegedProcessorTime; _stopwatch.Stop(); /* CALCULATE ELAPSED TIME */ var realTime = _stopwatch.ElapsedMilliseconds / 1000d; var userTime = GetDuration(_userProcessorTimeStart, _userProcessorTimeEnd); var systemTime = GetDuration(_privilegedProcessorTimeStart, _privilegedProcessorTimeEnd); Output(realTime, userTime, systemTime); return result; }
public override Expression Call(Expression expr) { if (expr.Elements.Count < 4) throw new MistException("defmacro must have at least 3 arguments (symbol, parameters list, and a body)"); var symbol = expr.Elements.Second(); if (symbol.Token.Type != Tokens.SYMBOL) throw new MistException(string.Format("The first argument to defmacro does not evaluate to a symbol ({0})", symbol.Token)); var parameters = expr.Elements.Third() as ListExpression; if (parameters == null) throw new MistException("The second argument to defmacro must be a list"); var name = symbol.Token.Text; var macro = new Macro( symbol: name, formalParams: parameters, body: expr.Elements.Skip(3), environment: Environment); Environment.CurrentScope.AddBinding(symbol, macro); return macro; }
public override Expression Call(Expression expr) { if (expr.Elements.Count != 2 || expr.Elements.Second().Token.Type != Tokens.STRING) throw new MistException("Load takes a single string argument."); var source = Environment.EvaluateString("(slurp " + expr.Elements.Second().ToString() + ")"); return Environment.EvaluateString(source.Value.ToString()); }
public void AddBinding(Expression expr) { //TODO: should probably store the symbol here as well // will make it possible to retrieve the doc string from the symbol instead of the value // see AllBindings as well AddBinding(new SymbolExpression(expr.Token.Text), expr); }
public Lambda(Expression expr, Environment environment) : base("anonymous", environment.CurrentScope) { _environment = environment; _formalParameters = new FormalParameters(expr.Elements.Second()); Precondition = args => args.Count() == _formalParameters.Count; Implementation = args => expr.Elements.Skip(2).Evaluate(_environment.CurrentScope); }
public FormalParameters(Expression expr) { if (!(expr is ListExpression)) throw new MistException("Formal parameters must be a list, not " + expr); if (!expr.Elements.All(p => p.Token.Type == Tokens.SYMBOL)) throw new MistException("Only symbols allowed in formal paremeters. " + expr); _parameters = (ListExpression)expr; }
public override Expression Call(Expression expr) { var symbol = expr.Elements.Second(); if (symbol.Token.Type != Tokens.SYMBOL) throw new MistException(string.Format("The first argument to set! does not evaluate to a symbol ({0})", symbol.Token)); Expression value = Evaluate(expr.Elements.Third()); Environment.CurrentScope.UpdateBinding(symbol, value); return value; }
public override Expression Call(Expression expr) { var bindings = expr.Elements.Second().Elements; var tempScope = new Bindings() { ParentScope = Environment.CurrentScope }; for (int i = 0; i < bindings.Count - 1; i = i + 2) tempScope.AddBinding( bindings[i], bindings[i + 1].Evaluate(tempScope)); return Environment.WithScope(tempScope, () => expr.Elements.Skip(2).Evaluate(tempScope)); }
public void UpdateBinding(Expression symbol, Expression value) { string lookupKey = symbol.Token.Text; var k = _symbolBindings.FirstOrDefault(kv => kv.Key.Token.Text == lookupKey).Key; if (k != null) _symbolBindings[k] = value; else if (ParentScope != null) ParentScope.UpdateBinding(symbol, value); else throw new SymbolResolveException(lookupKey); }
public override Expression Call(Expression expr) { var forms = expr.Elements.Skip(1).ToList(); if (forms.Count() % 2 != 0) throw new MistException("COND requires an even number of forms"); for (int i = 0; i < forms.Count() - 1; i = i + 2) { var condition = forms[i].Evaluate(Environment.CurrentScope); if (condition.IsTrue) return forms[i + 1].Evaluate(Environment.CurrentScope); } return NIL.Instance; }
public override Expression Call(Expression expr) { //if (expr.Elements.Count != 2 || expr.Elements.Second().Token.Type != Tokens.STRING) // throw new MistException("Load takes a single string argument."); //var source = Environment.EvaluateString("(slurp " + expr.Elements.Second().ToString() + ")"); // WORK IN PROGRESS !!!! var typeName = expr.Elements[1].Token.Text; Type type = Type.GetType(typeName); object instance = Activator.CreateInstance(type); return instance.ToExpression(); }
public override Expression Call(Expression expr) { var symbol = expr.Elements.Second(); if (symbol.Token.Type != Tokens.SYMBOL) throw new MistException(string.Format("The first argument to def does not evaluate to a symbol ({0})", symbol.Token)); Expression value = null; if (expr.Elements.Count == 3) { value = Evaluate(expr.Elements.Third()); } else if (expr.Elements.Count == 4 && expr.Elements.Third().Token.Type == Tokens.STRING) { value = Evaluate(expr.Elements.Forth()); value.DocString = Evaluate(expr.Elements.Third()); // as StringExpression; } else throw new MistException("Special form 'def' needs 2 parameters (+ an optional doc string), not " + (expr.Elements.Count - 1)); Environment.CurrentScope.AddBinding(symbol, value); return symbol; }
public Functionoid(Expression e) { _objectExpression = e; }
public void AddBinding(Expression symbol, Expression expr) { _symbolBindings.Add(symbol, expr); }
public static void PRINT(Expression exp) { Console.WriteLine(exp); }
public static bool CanWrap(Expression e) { return !(e is ListExpression) && !(e is Function) && e.Value != null; }
public void UpdateReplMemory(Expression expr) { _global.UpdateBinding(m3, _global.Resolve(m2.Token.Text)); _global.UpdateBinding(m2, _global.Resolve(m1.Token.Text)); _global.UpdateBinding(m1, expr); }
public static Expression CallSpecialForm(Expression expr) { return _formsMap[expr.Elements.First().Token.Text](expr); }
protected void Evaluate(string source) { interpreter = new Interpreter(); result = interpreter.EvaluateString(source); }
public override Expression Call(Expression expr) { return new Lambda(expr, Environment); }
/// <summary> /// Delegates evaluation to expression itself, using current scope /// </summary> /// <param name="expr"></param> /// <returns></returns> public Expression Evaluate(Expression expr) { return expr.Evaluate(Environment.CurrentScope); }
public override Expression Call(Expression expr) { return expr.Elements.Second(); }
public static Expression Call(this Function f, Expression expr) { return f.Call(expr.AsEnumerable()); }
private bool IsMacro(Expression expr, Bindings scope) { return expr is SymbolExpression && scope.Resolve(expr.Token.Text) is Macro; }
public abstract Expression Call(Expression expr);