functions can now refer to themselves

halgari · halgari · commit 23865d7c3d4a · 2014-10-31T16:29:41.000-06:00
diff --git a/pixie/stdlib.lisp b/pixie/stdlib.lisp
@@ -474,15 +474,14 @@
 (defn swap! [a f & args]
   (reset! a (apply f @a args)))
 
-(def update-inner-f (fn inner-f
-                  ([m f k]
-                   (assoc m k (f (get m k))))
-                  ([m f k & ks]
-                    (assoc m k (apply update-inner-f m f ks)))))
-
 (defn update-in
   [m ks f & args]
-  (let [f (fn [m] (apply f m args))]
+  (let [f (fn [m] (apply f m args))
+        update-inner-f (fn update-inner-f
+                         ([m f k]
+                            (assoc m k (f (get m k))))
+                         ([m f k & ks]
+                            (assoc m k (apply update-inner-f m f ks))))]
     (apply update-inner-f m f ks)))
 
 (defn nil? [x]
diff --git a/pixie/vm/code.py b/pixie/vm/code.py
@@ -102,9 +102,6 @@ def set_macro(self):
     def is_macro(self):
         return self._is_macro
 
-    def _invoke(self, args):
-        raise NotImplementedError()
-
     def get_consts(self):
         raise NotImplementedError()
 
@@ -116,9 +113,12 @@ def stack_size(self):
         return 0
 
     def invoke(self, args):
-        result = self._invoke(args)
+        result = self.invoke(args)
         return result
 
+    def invoke_with(self, args, this_fn):
+        return self.invoke(args)
+
 
 class MultiArityFn(BaseCode):
     _type = object.Type(u"pixie.stdlib.MultiArityFn")
@@ -155,8 +155,11 @@ def get_fn(self, arity):
 
         affirm(False, u"Wrong number of args to fn: got " + unicode(str(arity)) + u" expected " + u",".join(acc))
 
-    def _invoke(self, args):
-        return self.get_fn(len(args)).invoke(args)
+    def invoke(self, args):
+        return self.invoke_with(args, self)
+
+    def invoke_with(self, args, self_fn):
+        return self.get_fn(len(args)).invoke_with(args, self_fn)
 
 
 
@@ -171,12 +174,15 @@ def __init__(self):
     def type(self):
         return NativeFn._type
 
-    def _invoke(self, args):
+    def invoke(self, args):
         return self.inner_invoke(args)
 
     def inner_invoke(self, args):
         raise NotImplementedError()
 
+    def invoke_with(self, args, this_fn):
+        return self.invoke(args)
+
 
 class Code(BaseCode):
     """Interpreted code block. Contains consts and """
@@ -201,9 +207,12 @@ def with_meta(self, meta):
     def get_debug_points(self):
         return self._debug_points
 
-    def _invoke(self, args):
+    def invoke(self, args):
+        return self.invoke_with(args, self)
+
+    def invoke_with(self, args, this_fn):
         try:
-            return interpret(self, args)
+            return interpret(self, args, self_obj=this_fn)
         except object.WrappedException as ex:
             ex._ex._trace.append(object.PixieCodeInfo(self._name))
             raise
@@ -242,20 +251,23 @@ def __init__(self, code, required_arity, meta=nil):
     def with_meta(self, meta):
         return VariadicCode(self._code, self._required_arity, meta)
 
-    def _invoke(self, args):
+    def invoke(self, args):
+        return self.invoke_with(args, self)
+
+    def invoke_with(self, args, self_fn):
         from pixie.vm.array import array
         argc = len(args)
         if self._required_arity == 0:
-            return self._code.invoke([array(args)])
+            return self._code.invoke_with([array(args)], self_fn)
         if argc == self._required_arity:
             new_args = resize_list(args, len(args) + 1)
             new_args[len(args)] = array([])
-            return self._code.invoke(new_args)
+            return self._code.invoke_with(new_args, self_fn)
         elif argc > self._required_arity:
             start = slice_from_start(args, self._required_arity, 1)
             rest = slice_to_end(args, self._required_arity)
             start[self._required_arity] = array(rest)
-            return self._code.invoke(start)
+            return self._code.invoke_with(start, self_fn)
         affirm(False, u"Got " + unicode(str(argc)) + u" arg(s) need at least " + unicode(str(self._required_arity)))
 
 class Closure(BaseCode):
@@ -274,9 +286,12 @@ def __init__(self, code, closed_overs, meta=nil):
     def with_meta(self, meta):
         return Closure(self._code, self._closed_overs, meta)
 
-    def _invoke(self, args):
+    def invoke(self, args):
+        return self.invoke_with(args, self)
+
+    def invoke_with(self, args, self_fn):
         try:
-            return interpret(self, args)
+            return interpret(self, args, self_obj=self_fn)
         except object.WrappedException as ex:
             ex._ex._trace.append(object.PixieCodeInfo(self._code._name))
             raise
@@ -381,7 +396,10 @@ def deref(self):
     def is_defined(self):
         return self._root is not undefined
 
-    def _invoke(self, args):
+    def invoke_with(self, args, this_fn):
+        return self.invoke(args)
+
+    def invoke(self, args):
         return self.deref().invoke(args)
 
 class bindings(py_object):
@@ -510,7 +528,7 @@ class DefaultProtocolFn(NativeFn):
     def __init__(self, pfn):
         self._pfn = pfn
 
-    def _invoke(self, args):
+    def invoke(self, args):
         from pixie.vm.string import String
         tp = args[0].type()._name
         affirm(False, u"No override for " + tp + u" on " + self._pfn._name + u" in protocol " + self._pfn._protocol._name)
@@ -574,7 +592,7 @@ def get_protocol_fn(self, tp, rev):
         fn = self._dict.get(tp, self._default_fn)
         return promote(fn)
 
-    def _invoke(self, args):
+    def invoke(self, args):
         a = args[0].type()
         fn = self.get_protocol_fn(a, self._rev)
         try:
@@ -621,7 +639,7 @@ def get_fn(self, tp1, tp2, _rev):
         fn = d1.get(tp2, self._default_fn)
         return promote(fn)
 
-    def _invoke(self, args):
+    def invoke(self, args):
         affirm(len(args) >= 2, u"DoublePolymorphicFunctions take at least two args")
         a = args[0].type()
         b = args[1].type()
diff --git a/pixie/vm/compiler.py b/pixie/vm/compiler.py
@@ -275,7 +275,7 @@ def call_macro(var, form, ctx):
 class CompileMapRf(code.NativeFn):
     def __init__(self, ctx):
         self._ctx = ctx
-    def _invoke(self, args):
+    def invoke(self, args):
         map_entry = args[1]
         compile_form(rt.key(map_entry), self._ctx)
         compile_form(rt.val(map_entry), self._ctx)
@@ -407,7 +407,7 @@ def compile_platform_eq(form, ctx):
 def add_args(name, args, ctx):
     required_args = -1
     local_idx = 0
-    #ctx.add_local(name, Self())
+    ctx.add_local(name, Self())
     for x in range(rt.count(args)):
         arg = rt.nth(args, rt.wrap(x))
         affirm(isinstance(arg, symbol.Symbol), u"Argument names must be symbols")
@@ -456,7 +456,7 @@ def compile_fn(form, ctx):
 
 def compile_fn_body(name, args, body, ctx):
     new_ctx = Context(name._str, rt.count(args), ctx)
-    required_args = add_args(name, args, new_ctx)
+    required_args = add_args(name._str, args, new_ctx)
     bc = 0
 
     if name is not None:
diff --git a/pixie/vm/interpreter.py b/pixie/vm/interpreter.py
@@ -31,11 +31,13 @@ class Frame(object):
                        "base_code",
                        "closed_overs[*]",
                        "finished",
-                       "_is_continuation"
+                       "_is_continuation",
+                       "self_obj"
     ]
-    def __init__(self, code_obj, args):
+    def __init__(self, code_obj, args, self_obj):
         self = hint(self, access_directly=True, fresh_virtualizable=True)
         self.code_obj = code_obj
+        self.self_obj = self_obj
         self.sp = r_uint(0)
         self.ip = r_uint(0)
         self.stack = [None] * code_obj.stack_size()
@@ -169,7 +171,7 @@ def interpret(code_obj=None, args=[], self_obj = None, frame=None):
 
     if frame is None:
         assert code_obj is not None
-        frame = Frame(code_obj, args)
+        frame = Frame(code_obj, args, self_obj or code_obj)
 
 
 
@@ -302,7 +304,7 @@ def interpret(code_obj=None, args=[], self_obj = None, frame=None):
             argc = frame.get_inst()
             args = frame.pop_n(argc)
 
-            frame = Frame(frame.code_obj, args)
+            frame = Frame(frame.code_obj, args, frame.self_obj)
 
             jitdriver.can_enter_jit(bc=frame.bc,
                                   ip=frame.ip,
@@ -313,7 +315,7 @@ def interpret(code_obj=None, args=[], self_obj = None, frame=None):
             continue
 
         if inst == code.PUSH_SELF:
-            frame.push(frame.code_obj)
+            frame.push(frame.self_obj)
             continue
 
         if inst == code.DUP_NTH:
diff --git a/pixie/vm/stacklet.py b/pixie/vm/stacklet.py
@@ -57,7 +57,7 @@ def __init__(self, h):
     def type(self):
         return WrappedHandler._type
 
-    def _invoke(self, args):
+    def invoke(self, args):
         affirm(len(args) == 1, u"Only one arg to continuation allowed")
         global_state._from = global_state._to
         global_state._to = self
diff --git a/pixie/vm/test/test_stacklet.py b/pixie/vm/test/test_stacklet.py
@@ -5,7 +5,7 @@
 from pixie.vm.primitives import nil
 
 class YieldingFn(code.BaseCode):
-    def _invoke(self, args):
+    def invoke(self, args):
         assert len(args) == 2
         hdler = args[0]
         arg = args[1]
@@ -29,7 +29,7 @@ def yielding_fn(yld):
 class WrappingFn(code.NativeFn):
     def __init__(self, cont):
         self._cont = cont
-    def _invoke(self, args):
+    def invoke(self, args):
         ret = args[0]
         ret.invoke([self._cont.invoke([4])])
 
