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));
}
