public override SValue Evaluate(ExecEnvironment env) { if (!env.ContainsKey(varName)) { SValue tmp = (varName.First() == '@') ? (SValue) new SString(varName.Substring(1), true) : new SNull(true); if (env.ContainsKey(varName)) { return(env[varName]); } env[varName] = tmp; return(tmp); } var imd = env[varName].Evaluate(env); if (imd is SClosure && (imd as SClosure).Arguments.Count == 0) { // it is a closure that accepts 0 arguments, so just directly evaluate it return((imd as SClosure).Body.Evaluate(env)); } else { return(imd); } }
public override SValue Evaluate(ExecEnvironment env) { SValue v = varValue.Evaluate(env); SValue ret = v; if (!makeImmutable && v.Immutable) { ret = v.Clone(); ret.Immutable = false; } if (makeImmutable) { ret.Immutable = true; } ret.RefDict = null; ret.RefList = null; if (env.ContainsKey(varName) && env[varName].Immutable) { throw new VMException(varName + ": variable is immutable", headAtom); } env.NewVar(varName, ret); return(ret); }
public override SValue Evaluate(ExecEnvironment env) { SValue v = varValue.Evaluate(env); SValue ret = v; if (!makeImmutable && v.Immutable) { ret = v.Clone(); ret.Immutable = false; } if (makeImmutable) { ret.Immutable = true; } ret.RefDict = null; ret.RefList = null; if (nameExpr == null) { if (env.ContainsKey(varName) && env[varName].Immutable) { throw new VMException(varName + ": variable is immutable", headAtom); } if (makeImmutable) { env.NewVar(varName, ret); } else { env[varName] = ret; } } else { var n = nameExpr.Evaluate(env); if (n.RefDict?.Immutable == true || n.RefList?.Immutable == true) { throw new VMException(varName + ": variable is immutable", headAtom); } if (n.RefDict != null) { n.RefDict.Get <Dictionary <string, SValue> >()[n.RefDictKey] = ret; } else if (n.RefList != null) { n.RefList.Get <List <SValue> >()[n.RefListIndex] = ret; } else { throw new VMException("invalid variable setting", headAtom); } } return(ret); }
public bool ContainsKey(string key) { if (ParentEnv != null) { if (base.ContainsKey(key)) { return(true); } else { return(ParentEnv.ContainsKey(key)); } } else { return(base.ContainsKey(key)); } }
public object ExecuteString(string code, ExecEnvironment ee) { var p = new Parser(); var path = ""; var source = ""; if (ee.ContainsKey("~path")) { path = ee["~path"].Evaluate(null).Get <String>(); } if (ee.ContainsKey("~source")) { source = ee["~source"].Evaluate(null).Get <String>(); } var s = p.Parse(code, path, source); return(SExpression.Cast(s).Evaluate(ee).Get <object>()); }
public override SValue Evaluate(ExecEnvironment env) { var newEnv = new ExecEnvironment(); SValue _closure; SClosure closure = null; if (lambdaObject == null) { if (env.ContainsKey(closureName)) { _closure = env[closureName].Evaluate(env); closure = _closure as SClosure; } else { _closure = new SString(closureName); env[closureName] = _closure; } } else { _closure = lambdaObject.Evaluate(env); closure = _closure as SClosure; } List <SValue> arguments = SExpression.EvalSExpressions(this.arguments, env); if (closure == null) { List <SValue> ret = new List <SValue>(); ret.Add(_closure); foreach (var a in arguments) { ret.Add(a); } return(new SList(ret)); } if (closure.Arguments.Count() > arguments.Count()) { var argNames = closure.Arguments.Skip(arguments.Count); return(new SClosure( env, argNames.ToList(), new SECall( closure, arguments.ConvertAll(a => (SExpression)a) .Concat(argNames.Select(a => new SEVariable(a, headAtom, tailCompound))).ToList(), headAtom, tailCompound ) )); } // prepare the executing environment for (int i = 0; i < closure.Arguments.Count(); i++) { string argName = closure.Arguments[i]; if (argName.Length > 3 && argName.Substring(argName.Length - 3) == "...") { argName = argName.Substring(0, argName.Length - 3); newEnv[argName] = new SList(arguments.Skip(i).ToList()); break; } else { newEnv[argName] = arguments[i]; } } newEnv["~parent"] = new SDict(closure.InnerEnv); newEnv["~atom"] = new SObject(headAtom); newEnv.ParentEnv = closure.InnerEnv; return(closure.Body.Evaluate(newEnv)); }