protected override EvalResult EvalImpl(ScmEnvironment env)
{
if (!_clauses.Any())
{
return(new SelfEvaluatingExpression(false).ToResult());
}
else
{
foreach (var clause in _clauses)
{
var tokens = _tokenizer.Parse(_tokenizer.Strip(clause.Value)).ToArray();
if (tokens[0].Value == "else")
{
return(_factory.Create(tokens[1].Value).Eval(env));
}
else
{
var args = tokens.Select(x => _factory.Create(x.Value)).ToList();
if (True(args[0].Eval(env).Value))
{
return(args[1].Eval(env));
}
}
}
}
return(new SelfEvaluatingExpression(false).ToResult());
}
protected override EvalResult EvalImpl(ScmEnvironment env)
{
ScmExpression result = null;
foreach (var scmExpression in _exprs)
{
result = scmExpression.Eval(env).Value;
}
return(result.ToResult());
}
protected override EvalResult EvalImpl(ScmEnvironment env)
{
if (True(_predicate.Eval(env).Value))
{
return(_then.Eval(env));
}
else
{
return(_else.Eval(env));
}
}
private object[] MapValues(ScmExpression[] exps, ScmEnvironment env)
{
return(exps.Select(x => x.Eval(env).Value).Select(x =>
{
if (x is SelfEvaluatingExpression)
{
return (x as SelfEvaluatingExpression).Value;
}
else
{
return x;
}
}).ToArray());
}
protected override EvalResult EvalImpl(ScmEnvironment env)
{
var exp = @Operator.Eval(env).Value;
if (exp is ProcedureExpression)
{
var proc = exp as ProcedureExpression;
object ve;
object[] mappedOperands;
if (proc.Proc is PrimitiveProcedure)
{
mappedOperands =
Arguments.Select(x => x.Eval(env).Value)
.OfType <SelfEvaluatingExpression>()
.Select(x => x.Value)
.ToArray();
}
else
{
mappedOperands = MapValues(Arguments, env);
}
var applyResult = proc.Proc.Apply(mappedOperands);
if (applyResult.Success)
{
return(new SelfEvaluatingExpression(applyResult.Value).ToResult());
}
else
{
string msg = "";
if (@Operator is VariableExpression)
{
string procedureName = (@Operator as VariableExpression).VariableName;
msg = String.Format("Error while applying procedure {0}:{1}", procedureName,
Environment.NewLine);
}
return(EvalResult.Error(msg + applyResult.ErrorMessage));
}
}
else if (exp is ApplicationExpression)
{
var application = exp as ApplicationExpression;
return(application.Eval(env));
}
return(exp.ToResult());
}
protected override EvalResult EvalImpl(ScmEnvironment env)
{
if (_arguments[0].Type == TokenType.Symbol)
{
DefineVariable(_arguments[0].Value, _factory.Create(_arguments[1].Value), env);
}
else if (_arguments[0].Type == TokenType.Tuple)
{
var pars = _tokenizer.Parse(_tokenizer.Strip(_arguments[0].Value)).ToList();
var newVariable = pars[0].Value;
var lambda = new LambdaExpression(_factory.Create(_arguments[1].Value), pars.Skip(1).Select(x => x.Value).ToArray(), env);
var newValue = lambda.Eval(env).Value;
DefineVariable(newVariable, newValue, env);
}
return(new VoidExpression().ToResult());
}
public EvalResult Eval(ScmEnvironment env)
{
var result = this.EvalImpl(env);
if (result.Success)
{
var exp = this.EvalImpl(env).Value;
var resultExp = exp;
while (!(resultExp is SelfEvaluatingExpression) && !(resultExp is ProcedureExpression))
{
var innerResult = resultExp.Eval(env);
if (!innerResult.Success)
{
return(innerResult);
}
resultExp = resultExp.Eval(env).Value;
}
return(resultExp.ToResult());
}
else
{
return(result);
}
}
protected override EvalResult EvalImpl(ScmEnvironment env)
{
return(this.ToResult());
}
public LambdaProcedure(ScmExpression exp, ScmEnvironment env, string[] parameters)
{
_parameters = parameters;
_scmEnvironment = env;
_scmExpression = exp;
}
private void DefineVariable(string var, ScmExpression val, ScmEnvironment env)
{
env.Dict[var] = val;
}
protected override EvalResult EvalImpl(ScmEnvironment env)
{
throw new NotImplementedException();
}
public LambdaExpression(ScmExpression body, string[] parameters, ScmEnvironment env) : base(null)
{
_env = env;
_body = body;
_parameters = parameters;
}
protected override EvalResult EvalImpl(ScmEnvironment env)
{
var proc = new LambdaProcedure(_body, _env, _parameters);
return((new ProcedureExpression(proc)).ToResult());
}
protected override EvalResult EvalImpl(ScmEnvironment env)
{
SetVariable(_variable, _value.Eval(env).Value, env);
return(null);
}
protected override EvalResult EvalImpl(ScmEnvironment env)
{
var result = env.Lookup(_variableName);
return((result is ScmExpression ? result as ScmExpression : new SelfEvaluatingExpression(result)).ToResult());
}
protected abstract EvalResult EvalImpl(ScmEnvironment env);
public ScmProcedure Create(ScmExpression exp, ScmEnvironment env)
{
var variableName = (exp as VariableExpression).VariableName as string;
return(env.Dict[variableName] as ScmProcedure);
}
private void SetVariable(object variable, ScmExpression eval, ScmEnvironment env)
{
}
