public IForm ParseForm()
{
Token token = this.NextToken();
if (token == null)
return null;
if (token.Type == TokenType.Operator && token.Value == "-")
{
if (this.TryParseAtom("module"))
return this.ParseModuleForm();
if (this.TryParseAtom("export"))
return this.ParseExportForm();
throw new ParserException("Unknown form");
}
this.PushToken(token);
var fform = this.ParseFunctionForm();
var fforms = new List<FunctionForm>();
fforms.Add(fform);
while (this.TryParseToken(TokenType.Separator, ";"))
fforms.Add(this.ParseFunctionForm());
this.ParsePoint();
if (fforms.Count == 1)
return fform;
return new MultiFunctionForm(fforms);
}
public object Evaluate(Context context, bool withvars = false)
{
IList<object> elements = new List<object>();
foreach (var expr in this.expressions)
elements.Add(expr.Evaluate(context, withvars));
return new Tuple(elements);
}
public object Evaluate(Context context, bool withvars = false)
{
Context newcontext = new Context();
IList<object> parameters = new List<object>();
foreach (var pexpr in this.parameterexpressions)
parameters.Add(pexpr.Evaluate(newcontext, true));
var func = new Function(context, parameters, this.body);
return func;
}
public object Evaluate(Context context)
{
Context newcontext = new Context();
IList<object> parameters = new List<object>();
foreach (var pexpr in this.parameterexpressions)
parameters.Add(pexpr.Evaluate(newcontext, true));
var func = new Function(context, parameters, this.body);
context.SetValue(string.Format("{0}/{1}", this.name, parameters.Count), func);
return func;
}
public object Evaluate(Context context, bool withvars = false)
{
object namevalue = this.nameexpression.Evaluate(context, withvars);
IList<object> arguments = new List<object>();
foreach (var argexpr in this.argumentexpressions)
arguments.Add(argexpr.Evaluate(context, withvars));
if (namevalue is Atom)
namevalue = context.GetValue(string.Format("{0}/{1}", ((Atom)namevalue).Name, this.argumentexpressions.Count));
IFunction func = (IFunction)namevalue;
return new DelayedCall(func, context, arguments);
}
public object Evaluate(Context context, bool withvars = false)
{
int arity = this.expressions[0].ParameterExpressions.Count;
if (!this.expressions.Skip(1).All(f => f.ParameterExpressions.Count == arity))
throw new Exception("head mismatch");
IList<Function> functions = new List<Function>();
foreach (var form in this.Expressions)
functions.Add((Function)form.Evaluate(context, true));
var func = new MultiFunction(functions);
return func;
}
private static object Filter(Context context, IList<object> arguments)
{
IFunction function = (IFunction)arguments[0];
List list = (List)arguments[1];
IList<object> elements = new List<object>();
while (list != null)
{
var result = function.Apply(context, new object[] { list.Head });
if (true.Equals(result))
elements.Add(list.Head);
list = (List)list.Tail;
}
return List.MakeList(elements);
}
public object Evaluate(Context context)
{
string name = this.forms[0].Name;
int arity = this.forms[0].ParameterExpressions.Count;
if (!this.forms.Skip(1).All(f => f.Name == name && f.ParameterExpressions.Count == arity))
throw new Exception("head mismatch");
IList<Function> functions = new List<Function>();
foreach (var form in this.Forms)
functions.Add((Function)form.Evaluate(context));
var func = new MultiFunction(functions);
context.SetValue(string.Format("{0}/{1}", name, arity), func);
return func;
}
public object Evaluate(Context context, bool withvars = false)
{
object modulevalue = this.moduleexpression.Evaluate(context, withvars);
object namevalue = this.nameexpression.Evaluate(context, withvars);
string modulename = ((Atom)modulevalue).Name;
string name = string.Format("{0}/{1}", ((Atom)namevalue).Name, this.argumentexpressions.Count);
IList<object> arguments = new List<object>();
foreach (var argexpr in this.argumentexpressions)
arguments.Add(argexpr.Evaluate(context, withvars));
Module module = context.GetValue(modulename) as Module;
if (module == null || !module.ExportNames.Contains(name) || !(module.Context.GetValue(name) is IFunction))
throw new Exception(string.Format("undefined function {0}:{1}", modulename, name));
IFunction func = (IFunction)module.Context.GetValue(name);
return func.Apply(context, arguments);
}
public object Evaluate(Context context, bool withvars = false)
{
IList<object> elements = new List<object>();
foreach (var expr in this.expressions)
elements.Add(expr.Evaluate(context, withvars));
List tail = null;
if (this.tailexpression != null)
{
object tailvalue = this.tailexpression.Evaluate(context, withvars);
if (tailvalue is Variable)
return List.MakeList(elements, (Variable)tailvalue);
tail = (List)tailvalue;
}
if (elements.Count == 0 && tail == null)
return EmptyList.Instance;
return List.MakeList(elements, tail);
}
private static object Map(Context context, IList<object> arguments)
{
IFunction function = (IFunction)arguments[0];
List list = (List)arguments[1];
IList<object> elements = new List<object>();
while (list != null)
{
elements.Add(function.Apply(context, new object[] { list.Head }));
list = (List)list.Tail;
}
return List.MakeList(elements);
}
private IExpression ParseReceiveExpression()
{
IList<MatchBody> matches = new List<MatchBody>();
while (true)
{
var expr = this.ParseSimpleExpression();
// TODO review head evaluation
var head = expr.Evaluate(new Context(), true);
this.ParseToken(TokenType.Operator, "->");
var body = this.ParseCompositeExpression();
matches.Add(new MatchBody(head, body));
if (!this.TryParseToken(TokenType.Separator, ";"))
break;
}
this.ParseToken(TokenType.Atom, "end");
return new ReceiveExpression(matches);
}
private IExpression ParseFunExpression()
{
var fexpr = this.ParseSimpleFunExpression();
var fexprs = new List<FunExpression>();
fexprs.Add(fexpr);
while (this.TryParseToken(TokenType.Separator, ";"))
fexprs.Add(this.ParseSimpleFunExpression());
this.ParseToken(TokenType.Atom, "end");
if (fexprs.Count == 1)
return fexpr;
return new MultiFunExpression(fexprs);
}
private IList<IExpression> ParseExpressionList()
{
List<IExpression> expressions = new List<IExpression>();
for (IExpression expr = this.ParseSimpleExpression(); expr != null; expr = this.ParseSimpleExpression())
{
expressions.Add(expr);
Token token = this.NextToken();
if (token != null && token.Type == TokenType.Separator && token.Value == ",")
continue;
if (token != null)
this.PushToken(token);
break;
}
return expressions;
}
private IForm ParseExportForm()
{
this.ParseToken(TokenType.Separator, "(");
this.ParseToken(TokenType.Separator, "[");
IList<string> names = new List<string>();
if (!this.TryParseToken(TokenType.Separator, "]"))
while (true)
{
string name = this.ParseAtom();
this.ParseToken(TokenType.Operator, "/");
int arity = this.ParseInteger();
names.Add(string.Format("{0}/{1}", name, arity));
if (!this.TryParseToken(TokenType.Separator, ","))
break;
}
this.ParseToken(TokenType.Separator, "]");
this.ParseToken(TokenType.Separator, ")");
this.ParsePoint();
return new ExportForm(names);
}
private IExpression ParseCompositeExpression()
{
IExpression expression = this.ParseMatchExpression();
if (expression == null)
return null;
IList<IExpression> expressions = new List<IExpression>();
expressions.Add(expression);
while (this.TryParseToken(TokenType.Separator, ","))
expressions.Add(this.ParseMatchExpression());
if (expressions.Count == 1)
return expression;
return new CompositeExpression(expressions);
}