Beispiel #1
0
 public void LoadVariable(List v) 
 {
     int level = v.Head;
     int pos = v.Tail;
     List frame = Nth(level, Env);
     dynamic val = Nth(pos, frame);
     Push(val);
 }
 public void Eval(MethodInfo mi)
 {
     var args = new List<dynamic>();
     for (int i = 0; i < mi.GetParameters().Length; ++i)
         args.Add(Pop());                
     var result = mi.Invoke(this, args.ToArray());
     if (mi.ReturnType != typeof(void))
         Push(result);
 }
Beispiel #3
0
 public static bool Occurs(string s, List e)
 {
     if (e.Head is string)
         if (e.Head == s) 
             return true;
     if (e.Head is List) 
         return Occurs(s, e.Head);
     return e.Tail == null ? false : Occurs(s, e.Tail);
 }
 public Expression LetToExpr(Node node)
 {
     var exprs = new List<Expression>();
     foreach (var binding in node[0].Nodes) {
         var name = binding[0].Text;
         var param = AddBinding(Expression.Parameter(typeof(Object), name));
         exprs.Add(param);
         exprs.Add(Expression.Assign(Lookup(name), ToExpr(binding[1])));
     }
     exprs.Add(ToExpr(node["Term"]));
     return Expression.Block(exprs);
 }
Beispiel #5
0
 public void Select(List a, List b) 
 { 
     Push(Code, ref Dump); 
     Code = Pop() == List.Empty ? a : b; 
 }
Beispiel #6
0
 public void SetVariable(List v, dynamic val)
 {
 }
Beispiel #7
0
 public dynamic Pop(ref List list) 
 { 
     var top = list.Head; 
     list = list.Tail; 
     return top; 
 }
Beispiel #8
0
 public dynamic Nth(int n, List list)
 {
     return n == 0 
         ? list.Head 
         : Nth(n - 1, list.Tail);
 }
Beispiel #9
0
 public void Apply() 
 { 
     Push(Stack, ref Dump); 
     Push(Env, ref Dump); 
     Push(Code, ref Dump); 
     List closure = Pop();
     List paramlist = Pop();
     Env = closure.Tail;
     Push(paramlist, ref Env);
     Code = closure.Head;
     Stack = List.Empty;
 }
Beispiel #10
0
 public void Return()
 {
     var r = Pop();
     Code = Pop(ref Dump);
     Env = Pop(ref Dump);
     Stack = Pop(ref Dump);
     Push(r);
 }
Beispiel #11
0
 public void Eval(List xs)
 {
     for (; !xs.IsEmpty; xs = xs.Tail)
         Eval(xs.Head);            
 }
Beispiel #12
0
 public static void PrintBindings(List e1, List e2)
 {
     var bindings = Unifier.Unify(e1, e2);
     foreach (var kv in bindings)
         Console.WriteLine("Variable = {0}, Value = {1}", kv.Key, kv.Value);
 }
 /// <summary>
 /// The node has to be transformed before being passed
 /// </summary>
 /// <param name="n"></param>
 /// <returns></returns>
 public Expression ToExpr(Node n)
 {
     switch (n.Label)
     {
         case "Empty":
             return Noop;
         case "Return":
             return (n.Count > 0)
                 ? Expression.Return(GetReturnTarget(), ToExpr(n[0]), typeof(Object))
                 : Expression.Return(GetReturnTarget(), Expression.Constant(typeof(Object), null));
         case "If":
             return n.Count > 2
                 ? Expression.IfThenElse(Expression.Convert(ToExpr(n[0]), typeof(Boolean)), ToExpr(n[1]), ToExpr(n[2]))
                 : Expression.IfThen(Expression.Convert(ToExpr(n[0]), typeof(Boolean)), ToExpr(n[1]));
         case "Else":
             return ToExpr(n[0]);
         case "For":                    
             return CompileForLoop(ToExpr(n[0]), ToExpr(n[1]), ToExpr(n[2]), ToExpr(n[3]));
         case "VarDecl":
             {
                 var r = AddBinding(Expression.Variable(typeof(object), n[0].Text));
                 if (n.Count > 1)
                     r = Expression.Assign(r, ToExpr(n[1]));
                 return r;
             }
         case "Block":
             return ScopedExpr(() => Expression.Block(n.Nodes.Select(ToExpr)));
         case "TertiaryExpr":
             return Expression.Condition(ToExpr(n[0]), ToExpr(n[1]), ToExpr(n[2]));
         case "BinaryExpr":
             return Expression.Call(null, Primitives.GetMethodFromBinaryOperator(n[1].Text), ToExpr(n[0]), ToExpr(n[2]));
         case "AssignExpr":
             return Expression.Assign(ToExpr(n[0]), ToExpr(n[2]));
         case "FieldExpr":
             return Expression.Field(ToExpr(n[0]), n[1].Text);
         case "IndexExpr":
             return CompileIndexExpr(ToExpr(n[0]), ToExpr(n[2]));
         case "CallExpr":
             return CompileCallExpr(ToExpr(n[0]), n[1].Nodes.Select(ToExpr));
         case "MethodCallExpr":
             {
                 var self = ToExpr(n[0]);
                 var func = Expression.Field(self, n[1].Text);
                 var args = new List<Expression>() { self };
                 args.AddRange(n[2].Nodes.Select(ToExpr));
                 return CompileCallExpr(func, args);
             }
         case "PrefixExpr":
             switch (n[0].Text)
             {
                 case "!": return Expression.Not(ToExpr(n[1]));
                 case "~": return Expression.OnesComplement(ToExpr(n[1]));
                 case "-": return Expression.Negate(ToExpr(n[1]));
                 default: throw new Exception("Unrecognized prefix operator " + n[0].Text);
             }
         case "NewExpr":
             return ScopedExpr(() => 
                 {
                     AddBinding("this", Expression.Constant(new JsonObject()));
                     return ToExpr(n[0]);
                 });                    
         case "ParenExpr":
             return ToExpr(n[0]);
         case "AnonFunc":
             {
                 var ps = n[0].Nodes.Select(x => Expression.Parameter(typeof(Object), x.Text));
                 return CreateStatementLambda(ps, () => ToExpr(n[1]));
             };
         case "Object":
             throw new NotImplementedException();
         case "Array":
             return Expression.NewArrayInit(typeof(object), n.Nodes.Select(ToExpr));
         case "Identifier":
             return Lookup(n.Text);
         case "String":
             return Expression.Constant(Utilities.Unquote(n.Text));
         case "Integer":
             return Expression.Convert(Expression.Constant(int.Parse(n.Text)), typeof(Object));
         case "Float":
             return Expression.Convert(Expression.Constant(float.Parse(n.Text)), typeof(Object));
         case "True":
             return Expression.Convert(Expression.Constant(true), typeof(Object));
         case "False":
             return Expression.Convert(Expression.Constant(false), typeof(Object));
         case "Null":
             return Expression.Constant(null);
         default:
             throw new Exception("Unrecognized node type " + n.Label);
     }
 }
Beispiel #14
0
 public Rule(IEnumerable<Rule> rules)
 {
     if (rules.Any(r => r == null)) throw new Exception("No child rule can be null");
     Children = new List<Rule>(rules);
 }
Beispiel #15
0
 public void Join() 
 { 
     Code = Pop(ref Dump); 
 }
Beispiel #16
0
 public void LoadFunction(List f) 
 { 
     Push(List.Cons(f, Env)); 
 }
Beispiel #17
0
 public void TailApply()
 {
     List closure = Pop();
     List paramlist = Pop();
     Env = List.Cons(closure.Tail, Env.Tail);
     Push(paramlist, ref Env);
     Code = closure.Head;
     Stack = List.Empty;
 }
Beispiel #18
0
 public void Push(object o, ref List list) 
 { 
     list = List.Cons(o, list); 
 }
Beispiel #19
0
 public void Assign(ParserState state)
 {
     input = state.input; 
     pos = state.pos; 
     nodes = state.nodes;
 }