stacklets added

halgari · halgari · commit 05add6453aca · 2014-10-02T16:35:39.000-06:00
diff --git a/pixie/vm/code.py b/pixie/vm/code.py
@@ -1,3 +1,4 @@
+py_object = object
 import pixie.vm.object as object
 from pixie.vm.primitives import nil, true, false
 from rpython.rlib.rarithmetic import r_uint
@@ -157,7 +158,7 @@ def deref(self):
         return val
 
 
-class Namespace(__builtins__.object):
+class Namespace(py_object):
     def __init__(self, name):
         self._registry = {}
         self._name = name
@@ -173,7 +174,7 @@ def intern_or_make(self, name):
     def get(self, name, default):
         return self._registry.get(name, default)
 
-class NamespaceRegistry(__builtins__.object):
+class NamespaceRegistry(py_object):
     def __init__(self):
         self._registry = {}
 
diff --git a/pixie/vm/numbers.py b/pixie/vm/numbers.py
@@ -26,7 +26,7 @@ def type(self):
         return Integer._type
 
 zero_int = Integer(0)
-one_int = Integer(0)
+one_int = Integer(1)
 
 IMath = Protocol("IMath")
 _add = DoublePolymorphicFn("-add", IMath)
diff --git a/pixie/vm/protocols.py b/pixie/vm/protocols.py
@@ -4,7 +4,7 @@
 from pixie.vm.primitives import true, false, nil
 from pixie.vm.numbers import Integer, zero_int, _add
 import rpython.rlib.jit as jit
-
+import rpython.rlib.rstacklet as rstacklet
 
 
 defprotocol("pixie.stdlib", "ISeq", ["-first", "-next"])
@@ -80,4 +80,6 @@ def conj(a, b):
 def nth(a, b):
     return rt._nth(a, b)
 
+
+
 import pixie.vm.rt as rt
diff --git a/pixie/vm/reader.py b/pixie/vm/reader.py
@@ -1,3 +1,4 @@
+py_object = object
 import pixie.vm.object as object
 from pixie.vm.primitives import nil, true, false
 import pixie.vm.numbers as numbers
@@ -64,7 +65,7 @@ def eat_whitespace(rdr):
         return
 
 
-class ReaderHandler(__builtins__.object):
+class ReaderHandler(py_object):
     def invoke(self, rdr, ch):
         pass
 
diff --git a/pixie/vm/rt.py b/pixie/vm/rt.py
@@ -4,6 +4,9 @@ def unwrap(fn):
     return lambda *args: fn.invoke(list(args))
 
 def init():
+    if globals().has_key("__inited__"):
+        return
+
     import pixie.vm.protocols as proto
     from pixie.vm.code import BaseCode
     for name, fn in proto.__dict__.iteritems():
@@ -16,5 +19,7 @@ def init():
         if isinstance(fn, BaseCode):
             globals()[name] = unwrap(fn)
 
+    globals()["__inited__"] = True
+
 
 
diff --git a/pixie/vm/stacklet.py b/pixie/vm/stacklet.py
@@ -0,0 +1,51 @@
+py_object = object
+import pixie.vm.object as object
+from pixie.vm.primitives import nil, true, false
+from pixie.vm.code import BaseCode
+from pixie.vm.numbers import Integer
+import pixie.vm.protocols as proto
+from  pixie.vm.code import extend, as_var
+from rpython.rlib.rarithmetic import r_uint as r_uint32, intmask, widen
+import rpython.rlib.jit as jit
+import pixie.vm.rt as rt
+import rpython.rlib.rstacklet as rstacklet
+
+th = rstacklet.StackletThread(None)
+
+class Box(py_object):
+    def __init__(self):
+        self._val = None
+
+box = Box()
+
+class WrappedHandler(BaseCode):
+    _type = object.Type("Stacklet")
+    def __init__(self, h, box):
+        self._h = h
+        self._box = box
+
+    def switch_to(self, val):
+        self._box._val = val
+        self._h = th.switch(self._h)
+        return self._box._val
+
+    def _invoke(self, args):
+        assert len(args) == 1
+        return self.switch_to(args[0])
+
+
+
+def new_stacklet(f, val):
+    global box
+    box = Box()
+    self_box = box
+    def default_handler(h, o):
+        global box
+        handler = WrappedHandler(h, box)
+        box = None
+        handler._h = th.switch(handler._h)
+        retval = f.invoke([handler, val])
+        return handler._h
+
+    h = th.new(default_handler)
+    return WrappedHandler(h, self_box)
diff --git a/pixie/vm/test/test_compile.py b/pixie/vm/test/test_compile.py
@@ -59,13 +59,13 @@ def test_return_self():
 
 def test_recursive():
     retval = eval_string("""((fn rf [x]
-                               (if (platform= x 100)
+                               (if (platform= x 10)
                                    x
                                    (recur (+ x 1))))
                                0)""")
 
     assert isinstance(retval, Integer)
-    assert retval.int_val() == 100
+    assert retval.int_val() == 10
 
 def test_closures():
     retval = eval_string("""((fn [x] ((fn [] x))) 42)""")
@@ -92,21 +92,21 @@ def test_native():
 
 def test_build_list():
     retval = eval_string("""((fn [i lst]
-                              (if (platform= i 100)
+                              (if (platform= i 10)
                                 (count lst)
                                 (recur (+ i 1) (cons i lst)))) 0 nil)
      """)
 
-    assert isinstance(retval, Integer) and retval.int_val() == 100
+    assert isinstance(retval, Integer) and retval.int_val() == 10
 
 def test_build_vector():
     retval = eval_string("""((fn [i lst]
-                              (if (platform= i 100)
+                              (if (platform= i 10)
                                 (count lst)
                                 (recur (+ i 1) (conj lst i)))) 0 [])
      """)
 
-    assert isinstance(retval, Integer) and retval.int_val() == 100
+    assert isinstance(retval, Integer) and retval.int_val() == 10
 #
 # def test_handlers():
 #     retval = eval_string("""(def x 42)
diff --git a/pixie/vm/test/test_stacklet.py b/pixie/vm/test/test_stacklet.py
@@ -0,0 +1,30 @@
+import pixie.vm.stacklet as stacklet
+import pixie.vm.code as code
+import pixie.vm.rt as rt
+import pixie.vm.numbers as numbers
+from pixie.vm.primitives import nil
+
+class YieldingFn(code.BaseCode):
+    def _invoke(self, args):
+        assert len(args) == 2
+        hdler = args[0]
+        arg = args[1]
+
+        hdler.invoke([numbers.zero_int])
+        hdler.invoke([numbers.one_int])
+        hdler.invoke([numbers.Integer(2)])
+
+        return
+
+
+
+def test_stacklets():
+    st = stacklet.new_stacklet(YieldingFn(), nil)
+    result = st.invoke([nil])
+    assert isinstance(result, numbers.Integer) and result.int_val() == 0
+    result = st.invoke([nil])
+    assert isinstance(result, numbers.Integer) and result.int_val() == 1
+    result = st.invoke([nil])
+    assert isinstance(result, numbers.Integer) and result.int_val() == 2
+
+    pass
