[pypy-svn] r26563 - in pypy/dist/pypy: interpreter interpreter/test module/__builtin__ module/_pickle_support
ericvrp at codespeak.net
ericvrp at codespeak.net
Sat Apr 29 09:27:46 CEST 2006
Author: ericvrp
Date: Sat Apr 29 09:27:37 2006
New Revision: 26563
Modified:
pypy/dist/pypy/interpreter/function.py
pypy/dist/pypy/interpreter/module.py
pypy/dist/pypy/interpreter/test/test_pickle.py
pypy/dist/pypy/interpreter/typedef.py
pypy/dist/pypy/module/__builtin__/__init__.py
pypy/dist/pypy/module/__builtin__/app_functional.py
pypy/dist/pypy/module/_pickle_support/__init__.py
pypy/dist/pypy/module/_pickle_support/maker.py
Log:
Merge picklesupport brancj back into the trunk.
Modified: pypy/dist/pypy/interpreter/function.py
==============================================================================
--- pypy/dist/pypy/interpreter/function.py (original)
+++ pypy/dist/pypy/interpreter/function.py Sat Apr 29 09:27:37 2006
@@ -169,7 +169,7 @@
def descr_function_repr(self):
return self.getrepr(self.space, 'function %s' % (self.name,))
- def descr__reduce__(self, space):
+ def descr_function__reduce__(self, space):
from pypy.interpreter.mixedmodule import MixedModule
w_mod = space.getbuiltinmodule('_pickle_support')
mod = space.interp_w(MixedModule, w_mod)
@@ -181,7 +181,6 @@
w_closure = space.newtuple([w(cell) for cell in self.closure])
tup = [
w(self.code),
- #space.newdict([]), #XXX because pickle.py has no _pickle_moduledict yet...
self.w_func_globals,
w(self.name),
space.newtuple(self.defs_w),
@@ -390,6 +389,19 @@
return space.w_False
return space.eq(self.w_function, other.w_function)
+ def descr_method__reduce__(self, space):
+ from pypy.interpreter.mixedmodule import MixedModule
+ w_mod = space.getbuiltinmodule('_pickle_support')
+ mod = space.interp_w(MixedModule, w_mod)
+ new_inst = mod.get('method_new')
+ w = space.wrap
+ w_instance = self.w_instance or space.w_None
+ if space.is_w( self.w_class, space.w_None ):
+ tup = [self.w_function, w_instance]
+ else:
+ tup = [self.w_function, w_instance, self.w_class]
+ return space.newtuple([new_inst, space.newtuple(tup)])
+
class StaticMethod(Wrappable):
"""A static method. Note that there is one class staticmethod at
app-level too currently; this is only used for __new__ methods."""
Modified: pypy/dist/pypy/interpreter/module.py
==============================================================================
--- pypy/dist/pypy/interpreter/module.py (original)
+++ pypy/dist/pypy/interpreter/module.py Sat Apr 29 09:27:37 2006
@@ -35,3 +35,24 @@
w_doc = space.w_None
space.setitem(self.w_dict, space.new_interned_str('__name__'), w_name)
space.setitem(self.w_dict, space.new_interned_str('__doc__'), w_doc)
+
+ def descr__reduce__(self, space):
+ w_name = space.finditem(self.w_dict, space.wrap('__name__'))
+ if (w_name is None or
+ not space.is_true(space.isinstance(w_name, space.w_str))):
+ # maybe raise exception here (XXX this path is untested)
+ return space.w_None
+ w_modules = space.sys.get('modules')
+ if space.finditem(w_modules, w_name) is None:
+ #not imported case
+ from pypy.interpreter.mixedmodule import MixedModule
+ w_mod = space.getbuiltinmodule('_pickle_support')
+ mod = space.interp_w(MixedModule, w_mod)
+ new_inst = mod.get('module_new')
+ return space.newtuple([new_inst, space.newtuple([w_name,
+ self.getdict()]),
+ ])
+ #already imported case
+ w_import = space.builtin.get('__import__')
+ return space.newtuple([w_import, space.newtuple([w_name])])
+
Modified: pypy/dist/pypy/interpreter/test/test_pickle.py
==============================================================================
--- pypy/dist/pypy/interpreter/test/test_pickle.py (original)
+++ pypy/dist/pypy/interpreter/test/test_pickle.py Sat Apr 29 09:27:37 2006
@@ -24,21 +24,40 @@
assert func is result
del sys.modules['mod']
+ def test_pickle_not_imported_module(self):
+ import new
+ mod = new.module('mod')
+ mod.__dict__['a'] = 1
+ import pickle
+ pckl = pickle.dumps(mod)
+ result = pickle.loads(pckl)
+ assert mod.__name__ == result.__name__
+ assert mod.__dict__ == result.__dict__
+ #print mod.__dict__
+
def test_pickle_builtin_func(self):
import pickle
pckl = pickle.dumps(map)
result = pickle.loads(pckl)
assert map is result
- def test_pickle_nested_func(self):
- skip("work in progress")
+ def test_pickle_non_top_reachable_func(self):
def func():
return 42
+ global a
+ a = 42
+ del globals()['test_pickle_non_top_reachable_func']
import pickle
pckl = pickle.dumps(func)
result = pickle.loads(pckl)
- assert func == result
-
+ assert func.func_name == result.func_name
+ assert func.func_closure == result.func_closure
+ assert func.func_code == result.func_code
+ assert func.func_defaults == result.func_defaults
+ assert func.func_dict == result.func_dict
+ assert func.func_doc == result.func_doc
+ assert func.func_globals == result.func_globals
+
def test_pickle_cell(self):
def g():
x = [42]
@@ -83,40 +102,65 @@
result = pickle.loads(pckl)
assert tb == result
- def test_pickle_module(self): #XXX this passes for the wrong reason!
- skip("work in progress")
- def f():
- pass
+ def test_pickle_module(self):
import pickle
- mod = f.__module__ #XXX returns a string?
+ mod = pickle
pckl = pickle.dumps(mod)
result = pickle.loads(pckl)
- assert mod == result
+ assert mod is result
- def test_pickle_moduledict(self): #XXX this test is not correct!
- skip("work in progress")
- def f():
- pass
+ def test_pickle_moduledict(self):
import pickle
- modedict = f.__module__.__dict__
+ moddict = pickle.__dict__
pckl = pickle.dumps(moddict)
result = pickle.loads(pckl)
- assert mod == result
+ assert moddict is result
+
+ def test_pickle_bltins_module(self):
+ import pickle
+ mod = __builtins__
+ pckl = pickle.dumps(mod)
+ result = pickle.loads(pckl)
+ assert mod is result
def test_pickle_iter(self):
skip("work in progress")
def test_pickle_method(self):
skip("work in progress")
- class C(object):
+ class myclass(object):
def f(self):
pass
import pickle
- method = C.f
+ method = myclass.f
pckl = pickle.dumps(method)
result = pickle.loads(pckl)
assert method == result
+ def test_pickle_staticmethod(self):
+ skip("work in progress")
+ class myclass(object):
+ def f(self):
+ pass
+ f = staticmethod(f)
+ import pickle
+ method = myclass.f
+ pckl = pickle.dumps(method)
+ result = pickle.loads(pckl)
+ assert method == result
+
+ def test_pickle_classmethod(self):
+ skip("work in progress")
+ class myclass(object):
+ def f(self):
+ pass
+ f = classmethod(f)
+ import pickle
+ method = myclass.f
+ pckl = pickle.dumps(method)
+ result = pickle.loads(pckl)
+ assert method == result
+
def test_pickle_dictiter(self):
skip("work in progress")
import pickle
@@ -127,9 +171,14 @@
def test_pickle_enum(self):
skip("work in progress")
-
- def test_pickle_enumfactory(self):
- skip("work in progress")
+ import pickle
+ e = enumerate([])
+ pckl = pickle.dumps(e)
+ result = pickle.loads(pckl)
+ assert e == result
+
+ #def test_pickle_enumfactory(self):
+ # skip("work in progress")
def test_pickle_sequenceiter(self):
'''
@@ -144,13 +193,15 @@
result = pickle.loads(pckl)
assert liter == result
- def test_pickle_rangeiter(self):
- skip("work in progress")
+ def test_pickle_xrangeiter(self):
import pickle
riter = iter(xrange(5))
+ riter.next()
+ riter.next()
pckl = pickle.dumps(riter)
result = pickle.loads(pckl)
- assert riter == result
+ assert type(riter) is type(result)
+ assert list(result) == [2,3,4]
def test_pickle_generator(self):
skip("work in progress")
Modified: pypy/dist/pypy/interpreter/typedef.py
==============================================================================
--- pypy/dist/pypy/interpreter/typedef.py (original)
+++ pypy/dist/pypy/interpreter/typedef.py Sat Apr 29 09:27:37 2006
@@ -23,20 +23,20 @@
# xxx used by faking
self.fakedcpytype = None
self.add_entries(**rawdict)
-
+
def add_entries(self, **rawdict):
# xxx fix the names of the methods to match what app-level expects
for key, value in rawdict.items():
if isinstance(value, (interp2app, GetSetProperty)):
value.name = key
self.rawdict.update(rawdict)
-
+
def _freeze_(self):
# hint for the annotator: track individual constant instances of TypeDef
return True
-def get_unique_interplevel_subclass(cls, hasdict, wants_slots, needsdel=False):
+def get_unique_interplevel_subclass(cls, hasdict, wants_slots, needsdel=False):
key = cls, hasdict, wants_slots, needsdel
try:
return _subclass_cache[key]
@@ -53,10 +53,10 @@
def _buildusercls(cls, hasdict, wants_slots, wants_del):
"NOT_RPYTHON: initialization-time only"
typedef = cls.typedef
-
+
if hasdict and typedef.hasdict:
return get_unique_interplevel_subclass(cls, False, wants_slots, wants_del)
-
+
name = ['User']
if not hasdict:
name.append('NoDict')
@@ -65,9 +65,9 @@
if wants_del:
name.append('WithDel')
name.append(cls.__name__)
-
+
name = ''.join(name)
-
+
if wants_del:
supercls = get_unique_interplevel_subclass(cls, hasdict, wants_slots, False)
class Proto(object):
@@ -79,29 +79,29 @@
e.clear(self.space) # break up reference cycles
elif wants_slots:
supercls = get_unique_interplevel_subclass(cls, hasdict, False, False)
-
+
class Proto(object):
def user_setup_slots(self, nslots):
- self.slots_w = [None] * nslots
-
+ self.slots_w = [None] * nslots
+
def setslotvalue(self, index, w_value):
self.slots_w[index] = w_value
-
+
def getslotvalue(self, index):
return self.slots_w[index]
elif hasdict:
supercls = get_unique_interplevel_subclass(cls, False, False, False)
-
+
class Proto(object):
def getdict(self):
return self.w__dict__
-
+
def setdict(self, space, w_dict):
if not space.is_true(space.isinstance(w_dict, space.w_dict)):
raise OperationError(space.w_TypeError,
space.wrap("setting dictionary to a non-dict"))
self.w__dict__ = w_dict
-
+
def user_setup(self, space, w_subtype, nslots):
self.space = space
self.w__class__ = w_subtype
@@ -111,29 +111,29 @@
supercls = cls
class Proto(object):
-
+
def getclass(self, space):
return self.w__class__
-
+
def setclass(self, space, w_subtype):
# only used by descr_set___class__
self.w__class__ = w_subtype
-
-
+
+
def user_setup(self, space, w_subtype, nslots):
self.space = space
self.w__class__ = w_subtype
self.user_setup_slots(nslots)
-
+
def user_setup_slots(self, nslots):
assert nslots == 0
-
+
body = dict([(key, value)
for key, value in Proto.__dict__.items()
if not key.startswith('_') or key == '__del__'])
subcls = type(name, (supercls,), body)
-
+
return subcls
def make_descr_typecheck_wrapper(func, extraargs=(), cls=None):
@@ -144,7 +144,7 @@
if hasattr(func, 'im_func'):
assert func.im_class is cls
func = func.im_func
-
+
miniglobals = {
func.__name__: func,
'OperationError': OperationError
@@ -171,12 +171,12 @@
return %(name)s(space, obj, %(extra)s)
"""
miniglobals[cls_name] = cls
-
+
name = func.__name__
extra = ', '.join(extraargs)
source = py.code.Source(source % locals())
exec source.compile() in miniglobals
- return miniglobals['descr_typecheck_%s' % func.__name__]
+ return miniglobals['descr_typecheck_%s' % func.__name__]
def unknown_objclass_getter(space):
raise OperationError(space.w_TypeError,
@@ -213,16 +213,16 @@
def __init__(self, fget, fset=None, fdel=None, doc=None, cls=None):
"NOT_RPYTHON: initialization-time only"
objclass_getter, cls = make_objclass_getter(fget, cls)
- fget = make_descr_typecheck_wrapper(fget, cls=cls)
+ fget = make_descr_typecheck_wrapper(fget, cls=cls)
fset = make_descr_typecheck_wrapper(fset, ('w_value',), cls=cls)
- fdel = make_descr_typecheck_wrapper(fdel, cls=cls)
+ fdel = make_descr_typecheck_wrapper(fdel, cls=cls)
self.fget = fget
self.fset = fset
self.fdel = fdel
self.doc = doc
self.name = '<generic property>'
self.objclass_getter = objclass_getter
-
+
def descr_property_get(space, property, w_obj, w_cls=None):
"""property.__get__(obj[, type]) -> value
Read the value of the property of the given obj."""
@@ -233,7 +233,7 @@
return space.wrap(property)
else:
return property.fget(space, w_obj)
-
+
def descr_property_set(space, property, w_obj, w_value):
"""property.__set__(obj, value)
Change the value of the property of the given obj."""
@@ -242,7 +242,7 @@
raise OperationError(space.w_TypeError,
space.wrap("readonly attribute"))
fset(space, w_obj, w_value)
-
+
def descr_property_del(space, property, w_obj):
"""property.__delete__(obj)
Delete the value of the property from the given obj."""
@@ -251,7 +251,7 @@
raise OperationError(space.w_AttributeError,
space.wrap("cannot delete attribute"))
fdel(space, w_obj)
-
+
def descr_get_objclass(space, property):
return property.objclass_getter(space)
@@ -268,8 +268,8 @@
if w_value is None:
return space.w_None
else:
- return w_value
-
+ return w_value
+
return GetSetProperty(fget, cls=cls)
GetSetProperty.typedef = TypeDef(
@@ -294,13 +294,13 @@
self.index = index
self.name = name
self.w_cls = w_cls
-
+
def typecheck(self, space, w_obj):
if not space.is_true(space.isinstance(w_obj, self.w_cls)):
raise OperationError(space.w_TypeError,
space.wrap("descriptor '%s' for '%s' objects doesn't apply to '%s' object" %
(self.name, self.w_cls.name, space.type(w_obj).name)))
-
+
def descr_member_get(space, member, w_obj, w_w_cls=None):
"""member.__get__(obj[, type]) -> value
Read the slot 'member' of the given 'obj'."""
@@ -314,14 +314,14 @@
raise OperationError(space.w_AttributeError,
space.wrap(self.name)) # XXX better message
return w_result
-
+
def descr_member_set(space, member, w_obj, w_value):
"""member.__set__(obj, value)
Write into the slot 'member' of the given 'obj'."""
self = member
self.typecheck(space, w_obj)
w_obj.setslotvalue(self.index, w_value)
-
+
def descr_member_del(space, member, w_obj):
"""member.__delete__(obj)
Delete the value of the slot 'member' from the given 'obj'."""
@@ -355,7 +355,7 @@
from pypy.interpreter.function import Function, Method, StaticMethod
from pypy.interpreter.function import BuiltinFunction, descr_function_get
from pypy.interpreter.pytraceback import PyTraceback
-from pypy.interpreter.generator import GeneratorIterator
+from pypy.interpreter.generator import GeneratorIterator
from pypy.interpreter.nestedscope import Cell
from pypy.interpreter.special import NotImplemented, Ellipsis
@@ -415,7 +415,7 @@
__new__ = interp2app(PyCode.descr_code__new__.im_func),
__eq__ = interp2app(PyCode.descr_code__eq__),
__ne__ = descr_generic_ne,
- __reduce__ = interp2app(PyCode.descr__reduce__,
+ __reduce__ = interp2app(PyCode.descr__reduce__,
unwrap_spec=['self', ObjSpace]),
co_argcount = interp_attrproperty('co_argcount', cls=PyCode),
co_nlocals = interp_attrproperty('co_nlocals', cls=PyCode),
@@ -438,7 +438,7 @@
f_lineno = GetSetProperty(PyFrame.fget_f_lineno, PyFrame.fset_f_lineno),
f_back = GetSetProperty(PyFrame.fget_f_back),
f_lasti = GetSetProperty(PyFrame.fget_f_lasti),
- f_trace = GetSetProperty(PyFrame.fget_f_trace, PyFrame.fset_f_trace,
+ f_trace = GetSetProperty(PyFrame.fget_f_trace, PyFrame.fset_f_trace,
PyFrame.fdel_f_trace),
f_exc_type = GetSetProperty(PyFrame.fget_f_exc_type),
f_exc_value = GetSetProperty(PyFrame.fget_f_exc_value),
@@ -450,6 +450,8 @@
__new__ = interp2app(Module.descr_module__new__.im_func,
unwrap_spec=[ObjSpace, W_Root, Arguments]),
__init__ = interp2app(Module.descr_module__init__),
+ __reduce__ = interp2app(Module.descr__reduce__,
+ unwrap_spec=['self', ObjSpace]),
__dict__ = GetSetProperty(descr_get_dict, cls=Module), # module dictionaries are readonly attributes
__doc__ = 'module(name[, doc])\n\nCreate a module object.\nThe name must be a string; the optional doc argument can have any type.'
)
@@ -478,14 +480,14 @@
getset_func_dict = GetSetProperty(descr_get_dict, descr_set_dict, cls=Function)
Function.typedef = TypeDef("function",
- __new__ = interp2app(Function.descr_method__new__.im_func),
+ __new__ = interp2app(Function.descr_method__new__.im_func),
__call__ = interp2app(Function.descr_function_call,
unwrap_spec=['self', Arguments]),
__get__ = interp2app(descr_function_get),
__repr__ = interp2app(Function.descr_function_repr),
- __reduce__ = interp2app(Function.descr__reduce__,
+ __reduce__ = interp2app(Function.descr_function__reduce__,
unwrap_spec=['self', ObjSpace]),
- func_code = getset_func_code,
+ func_code = getset_func_code,
func_doc = getset_func_doc,
func_name = getset_func_name,
func_dict = getset_func_dict,
@@ -504,14 +506,16 @@
__call__ = interp2app(Method.descr_method_call,
unwrap_spec=['self', Arguments]),
__get__ = interp2app(Method.descr_method_get),
- im_func = interp_attrproperty_w('w_function', cls=Method),
- im_self = interp_attrproperty_w('w_instance', cls=Method),
+ im_func = interp_attrproperty_w('w_function', cls=Method),
+ im_self = interp_attrproperty_w('w_instance', cls=Method),
im_class = interp_attrproperty_w('w_class', cls=Method),
__getattribute__ = interp2app(Method.descr_method_getattribute),
__eq__ = interp2app(Method.descr_method_eq),
__ne__ = descr_generic_ne,
- __repr__ = interp2app(Method.descr_method_repr),
- # XXX getattribute/setattribute etc.pp
+ __repr__ = interp2app(Method.descr_method_repr),
+ __reduce__ = interp2app(Method.descr_method__reduce__,
+ unwrap_spec=['self', ObjSpace]),
+ # XXX getattribute/setattribute etc.pp
)
StaticMethod.typedef = TypeDef("staticmethod",
@@ -539,31 +543,29 @@
GeneratorIterator.typedef = TypeDef("generator",
next = interp2app(GeneratorIterator.descr_next),
__iter__ = interp2app(GeneratorIterator.descr__iter__),
- gi_running = interp_attrproperty('running', cls=GeneratorIterator),
- gi_frame = interp_attrproperty('frame', cls=GeneratorIterator),
+ gi_running = interp_attrproperty('running', cls=GeneratorIterator),
+ gi_frame = interp_attrproperty('frame', cls=GeneratorIterator),
)
Cell.typedef = TypeDef("cell",
__eq__ = interp2app(Cell.descr__eq__,
unwrap_spec=['self', ObjSpace, W_Root]),
__ne__ = descr_generic_ne,
- __reduce__ = interp2app(Cell.descr__reduce__,
+ __reduce__ = interp2app(Cell.descr__reduce__,
unwrap_spec=['self', ObjSpace]),
__setstate__ = interp2app(Cell.descr__setstate__,
- unwrap_spec=['self', ObjSpace, W_Root]),
+ unwrap_spec=['self', ObjSpace, W_Root]),
)
-Ellipsis.typedef = TypeDef("Ellipsis",
+Ellipsis.typedef = TypeDef("Ellipsis",
__repr__ = interp2app(Ellipsis.descr__repr__),
)
-NotImplemented.typedef = TypeDef("NotImplemented",
- __repr__ = interp2app(NotImplemented.descr__repr__),
+NotImplemented.typedef = TypeDef("NotImplemented",
+ __repr__ = interp2app(NotImplemented.descr__repr__),
)
ControlFlowException.typedef = TypeDef("ControlFlowException")
interptypes = [ val.typedef for name,val in globals().items() if hasattr(val,'__bases__') and hasattr(val,'typedef') ]
-
-
Modified: pypy/dist/pypy/module/__builtin__/__init__.py
==============================================================================
--- pypy/dist/pypy/module/__builtin__/__init__.py (original)
+++ pypy/dist/pypy/module/__builtin__/__init__.py Sat Apr 29 09:27:37 2006
@@ -31,6 +31,8 @@
'any' : 'app_functional.any',
'enumerate' : 'app_functional.enumerate',
'xrange' : 'app_functional.xrange',
+ '_install_pickle_support_for_xrange_iterator':
+ 'app_functional._install_pickle_support_for_xrange_iterator',
'sorted' : 'app_functional.sorted',
'reversed' : 'app_functional.reversed',
@@ -137,3 +139,15 @@
builtin = module.Module(space, None)
space.setitem(builtin.w_dict, space.wrap('None'), space.w_None)
return builtin
+
+ def setup_after_space_initialization(self):
+ """NOT_RPYTHON"""
+ space = self.space
+ # call installations for pickle support
+ for name in self.loaders.keys():
+ if name.startswith('_install_pickle_support_for_'):
+ w_install = self.get(name)
+ space.call_function(w_install)
+ # xxx hide the installer
+ space.delitem(self.w_dict, space.wrap(name))
+ del self.loaders[name]
\ No newline at end of file
Modified: pypy/dist/pypy/module/__builtin__/app_functional.py
==============================================================================
--- pypy/dist/pypy/module/__builtin__/app_functional.py (original)
+++ pypy/dist/pypy/module/__builtin__/app_functional.py Sat Apr 29 09:27:37 2006
@@ -362,6 +362,18 @@
def __len__(self):
return self._remaining
+ def __reduce__(self):
+ tup = (self._current, self._remaining, self._step)
+ return (make_xrange_iterator, tup)
+
+def make_xrange_iterator(*args):
+ return xrange_iterator(*args)
+
+def _install_pickle_support_for_xrange_iterator():
+ import _pickle_support
+ make_xrange_iterator.__module__ = '_pickle_support'
+ _pickle_support.make_xrange_iterator = make_xrange_iterator
+
# ____________________________________________________________
def sorted(lst, cmp=None, key=None, reverse=None):
Modified: pypy/dist/pypy/module/_pickle_support/__init__.py
==============================================================================
--- pypy/dist/pypy/module/_pickle_support/__init__.py (original)
+++ pypy/dist/pypy/module/_pickle_support/__init__.py Sat Apr 29 09:27:37 2006
@@ -7,7 +7,9 @@
}
interpleveldefs = {
- 'cell_new': 'maker.cell_new',
- 'code_new': 'maker.code_new',
- 'func_new': 'maker.func_new',
+ 'cell_new' : 'maker.cell_new',
+ 'code_new' : 'maker.code_new',
+ 'func_new' : 'maker.func_new',
+ 'module_new' : 'maker.module_new',
+ 'method_new' : 'maker.method_new',
}
Modified: pypy/dist/pypy/module/_pickle_support/maker.py
==============================================================================
--- pypy/dist/pypy/module/_pickle_support/maker.py (original)
+++ pypy/dist/pypy/module/_pickle_support/maker.py Sat Apr 29 09:27:37 2006
@@ -1,9 +1,10 @@
from pypy.interpreter.nestedscope import Cell
from pypy.interpreter.pycode import PyCode
-from pypy.interpreter.function import Function
+from pypy.interpreter.function import Function, Method
+from pypy.interpreter.module import Module
from pypy.rpython.objectmodel import instantiate
from pypy.interpreter.argument import Arguments
-from pypy.interpreter.baseobjspace import ObjSpace
+from pypy.interpreter.baseobjspace import ObjSpace, W_Root
#note: for now we don't use the actual value when creating the Cell.
@@ -22,3 +23,12 @@
w_type = space.gettypeobject(Function.typedef)
return space.call_args(w_type, __args__)
func_new.unwrap_spec = [ObjSpace, Arguments]
+
+def module_new(space, w_name, w_dict):
+ new_mod = Module(space, w_name, w_dict)
+ return space.wrap(new_mod)
+
+def method_new(space, __args__):
+ w_type = space.gettypeobject(Method.typedef)
+ return space.call_args(w_type, __args__)
+method_new.unwrap_spec = [ObjSpace, Arguments]
More information about the Pypy-commit
mailing list