[pypy-svn] pypy default: Backed out changeset b73a7c56d7ac
alex_gaynor
commits-noreply at bitbucket.org
Mon Jan 3 20:05:40 CET 2011
Author: Alex Gaynor <alex.gaynor at gmail.com>
Branch:
Changeset: r40349:9700ff477037
Date: 2011-01-03 13:04 -0600
http://bitbucket.org/pypy/pypy/changeset/9700ff477037/
Log: Backed out changeset b73a7c56d7ac
diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -375,9 +375,9 @@
else:
name = importname
- mod = Module(self, self.wrap(name))
- mod.install()
-
+ w_name = self.wrap(name)
+ w_mod = self.wrap(Module(self, w_name))
+ self.builtin_modules[name] = w_mod
return name
def getbuiltinmodule(self, name, force_init=False):
@@ -456,23 +456,22 @@
from pypy.module.exceptions import Module
w_name = self.wrap('exceptions')
self.exceptions_module = Module(self, w_name)
- self.exceptions_module.install()
+ self.builtin_modules['exceptions'] = self.wrap(self.exceptions_module)
from pypy.module.sys import Module
w_name = self.wrap('sys')
self.sys = Module(self, w_name)
- self.sys.install()
+ self.builtin_modules['sys'] = self.wrap(self.sys)
from pypy.module.imp import Module
w_name = self.wrap('imp')
- mod = Module(self, w_name)
- mod.install()
+ self.builtin_modules['imp'] = self.wrap(Module(self, w_name))
from pypy.module.__builtin__ import Module
w_name = self.wrap('__builtin__')
self.builtin = Module(self, w_name)
w_builtin = self.wrap(self.builtin)
- self.builtin.install()
+ self.builtin_modules['__builtin__'] = self.wrap(w_builtin)
self.setitem(self.builtin.w_dict, self.wrap('__builtins__'), w_builtin)
bootstrap_modules = set(('sys', 'imp', '__builtin__', 'exceptions'))
diff --git a/pypy/interpreter/mixedmodule.py b/pypy/interpreter/mixedmodule.py
--- a/pypy/interpreter/mixedmodule.py
+++ b/pypy/interpreter/mixedmodule.py
@@ -1,7 +1,7 @@
from pypy.interpreter.module import Module
from pypy.interpreter.function import Function, BuiltinFunction
-from pypy.interpreter import gateway
-from pypy.interpreter.error import OperationError
+from pypy.interpreter import gateway
+from pypy.interpreter.error import OperationError
from pypy.interpreter.baseobjspace import W_Root
import os, sys
@@ -19,24 +19,13 @@
# after startup().
w_initialdict = None
- def __init__(self, space, w_name):
- """ NOT_RPYTHON """
- Module.__init__(self, space, w_name)
- self.lazy = True
+ def __init__(self, space, w_name):
+ """ NOT_RPYTHON """
+ Module.__init__(self, space, w_name)
+ self.lazy = True
self.__class__.buildloaders()
self.loaders = self.loaders.copy() # copy from the class to the inst
- def install(self):
- """NOT_RPYTHON: install this module, and it's submodules into
- space.builtin_modules"""
- Module.install(self)
- if hasattr(self, "submodules"):
- name = self.space.unwrap(self.w_name)
- for sub_name, module_cls in self.submodules.iteritems():
- module_name = self.space.wrap("%s.%s" % (name, sub_name))
- m = module_cls(self.space, module_name)
- m.install()
-
def init(self, space):
"""This is called each time the module is imported or reloaded
"""
@@ -61,13 +50,13 @@
def get(self, name):
space = self.space
- w_value = self.getdictvalue(space, name)
- if w_value is None:
+ w_value = self.getdictvalue(space, name)
+ if w_value is None:
raise OperationError(space.w_AttributeError, space.wrap(name))
- return w_value
+ return w_value
- def call(self, name, *args_w):
- w_builtin = self.get(name)
+ def call(self, name, *args_w):
+ w_builtin = self.get(name)
return self.space.call_function(w_builtin, *args_w)
def getdictvalue(self, space, name):
@@ -78,12 +67,12 @@
def _load_lazily(self, space, name):
w_name = space.new_interned_str(name)
- try:
+ try:
loader = self.loaders[name]
- except KeyError:
- return None
- else:
- w_value = loader(space)
+ except KeyError:
+ return None
+ else:
+ w_value = loader(space)
func = space.interpclass_w(w_value)
# the idea of the following code is that all functions that are
# directly in a mixed-module are "builtin", e.g. they get a
@@ -101,19 +90,19 @@
func._builtinversion_ = bltin
bltin.name = name
w_value = space.wrap(bltin)
- space.setitem(self.w_dict, w_name, w_value)
+ space.setitem(self.w_dict, w_name, w_value)
return w_value
- def getdict(self):
- if self.lazy:
+ def getdict(self):
+ if self.lazy:
space = self.space
- for name in self.loaders:
- w_value = self.get(name)
- space.setitem(self.w_dict, space.new_interned_str(name), w_value)
+ for name in self.loaders:
+ w_value = self.get(name)
+ space.setitem(self.w_dict, space.new_interned_str(name), w_value)
self.lazy = False
self.w_initialdict = space.call_method(self.w_dict, 'items')
- return self.w_dict
+ return self.w_dict
def _freeze_(self):
self.getdict()
@@ -123,19 +112,19 @@
# not constant
return False
- def buildloaders(cls):
- """ NOT_RPYTHON """
- if not hasattr(cls, 'loaders'):
+ def buildloaders(cls):
+ """ NOT_RPYTHON """
+ if not hasattr(cls, 'loaders'):
# build a constant dictionary out of
- # applevel/interplevel definitions
+ # applevel/interplevel definitions
cls.loaders = loaders = {}
pkgroot = cls.__module__
appname = cls.get_applevel_name()
- for name, spec in cls.interpleveldefs.items():
- loaders[name] = getinterpevalloader(pkgroot, spec)
- for name, spec in cls.appleveldefs.items():
+ for name, spec in cls.interpleveldefs.items():
+ loaders[name] = getinterpevalloader(pkgroot, spec)
+ for name, spec in cls.appleveldefs.items():
loaders[name] = getappfileloader(pkgroot, appname, spec)
- assert '__file__' not in loaders
+ assert '__file__' not in loaders
if cls.expose__file__attribute:
loaders['__file__'] = cls.get__file__
if '__doc__' not in loaders:
@@ -151,27 +140,27 @@
w_obj = loader(space)
space.setattr(space.wrap(self), space.wrap(name), w_obj)
- def get__file__(cls, space):
- """ NOT_RPYTHON.
- return the __file__ attribute of a MixedModule
- which is the root-directory for the various
+ def get__file__(cls, space):
+ """ NOT_RPYTHON.
+ return the __file__ attribute of a MixedModule
+ which is the root-directory for the various
applevel and interplevel snippets that make
- up the module.
- """
- try:
- fname = cls._fname
- except AttributeError:
+ up the module.
+ """
+ try:
+ fname = cls._fname
+ except AttributeError:
pkgroot = cls.__module__
mod = __import__(pkgroot, None, None, ['__doc__'])
- fname = mod.__file__
+ fname = mod.__file__
assert os.path.basename(fname).startswith('__init__.py')
# make it clear that it's not really the interp-level module
# at this path that we are seeing, but an app-level version of it
fname = os.path.dirname(fname)
- cls._fname = fname
- return space.wrap(fname)
+ cls._fname = fname
+ return space.wrap(fname)
- get__file__ = classmethod(get__file__)
+ get__file__ = classmethod(get__file__)
def get__doc__(cls, space):
return space.wrap(cls.__doc__)
@@ -179,18 +168,18 @@
def getinterpevalloader(pkgroot, spec):
- """ NOT_RPYTHON """
- def ifileloader(space):
+ """ NOT_RPYTHON """
+ def ifileloader(space):
d = {'space' : space}
- # EVIL HACK (but it works, and this is not RPython :-)
- while 1:
- try:
- value = eval(spec, d)
- except NameError, ex:
- name = ex.args[0].split("'")[1] # super-Evil
+ # EVIL HACK (but it works, and this is not RPython :-)
+ while 1:
+ try:
+ value = eval(spec, d)
+ except NameError, ex:
+ name = ex.args[0].split("'")[1] # super-Evil
if name in d:
raise # propagate the NameError
- try:
+ try:
d[name] = __import__(pkgroot+'.'+name, None, None, [name])
except ImportError:
etype, evalue, etb = sys.exc_info()
@@ -200,9 +189,9 @@
# didn't help, re-raise the original exception for
# clarity
raise etype, evalue, etb
- else:
+ else:
#print spec, "->", value
- if hasattr(value, 'func_code'): # semi-evil
+ if hasattr(value, 'func_code'): # semi-evil
return space.wrap(gateway.interp2app(value))
try:
@@ -215,13 +204,13 @@
assert isinstance(value, W_Root), (
"interpleveldef %s.%s must return a wrapped object "
"(got %r instead)" % (pkgroot, spec, value))
- return value
- return ifileloader
-
+ return value
+ return ifileloader
+
applevelcache = {}
def getappfileloader(pkgroot, appname, spec):
- """ NOT_RPYTHON """
- # hum, it's a bit more involved, because we usually
+ """ NOT_RPYTHON """
+ # hum, it's a bit more involved, because we usually
# want the import at applevel
modname, attrname = spec.split('.')
impbase = pkgroot + '.' + modname
@@ -239,6 +228,7 @@
app = gateway.applevel(source, filename=fn, modname=appname)
applevelcache[impbase] = app
- def afileloader(space):
+ def afileloader(space):
return app.wget(space, attrname)
- return afileloader
+ return afileloader
+
diff --git a/pypy/interpreter/test/test_mixedmodule.py b/pypy/interpreter/test/test_mixedmodule.py
deleted file mode 100644
--- a/pypy/interpreter/test/test_mixedmodule.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from pypy.interpreter.mixedmodule import MixedModule
-
-
-class TestMixedModule(object):
- def test_install(self):
- class Module(MixedModule):
- interpleveldefs = {}
- appleveldefs = {}
-
- m = Module(self.space, self.space.wrap("test_module"))
- m.install()
-
- assert self.space.builtin_modules["test_module"] is m
-
- def test_submodule(self):
- class SubModule(MixedModule):
- interpleveldefs = {}
- appleveldefs = {}
-
- class Module(MixedModule):
- interpleveldefs = {}
- appleveldefs = {}
- submodules = {
- "sub": SubModule
- }
-
- m = Module(self.space, self.space.wrap("test_module"))
- m.install()
-
- assert self.space.builtin_modules["test_module"] is m
- assert isinstance(self.space.builtin_modules["test_module.sub"], SubModule)
diff --git a/pypy/interpreter/module.py b/pypy/interpreter/module.py
--- a/pypy/interpreter/module.py
+++ b/pypy/interpreter/module.py
@@ -10,19 +10,14 @@
def __init__(self, space, w_name, w_dict=None):
self.space = space
- if w_dict is None:
+ if w_dict is None:
w_dict = space.newdict(module=True)
- self.w_dict = w_dict
- self.w_name = w_name
+ self.w_dict = w_dict
+ self.w_name = w_name
if w_name is not None:
space.setitem(w_dict, space.new_interned_str('__name__'), w_name)
self.startup_called = False
- def install(self):
- """NOT_RPYTHON: installs this module into space.builtin_modules"""
- w_mod = self.space.wrap(self)
- self.space.builtin_modules[self.space.unwrap(self.w_name)] = w_mod
-
def setup_after_space_initialization(self):
"""NOT_RPYTHON: to allow built-in modules to do some more setup
after the space is fully initialized."""
@@ -55,14 +50,14 @@
def descr_module__init__(self, w_name, w_doc=None):
space = self.space
self.w_name = w_name
- if w_doc is None:
+ if w_doc is None:
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
+ 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
@@ -72,9 +67,9 @@
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')
+ new_inst = mod.get('module_new')
return space.newtuple([new_inst, space.newtuple([w_name,
- self.getdict()]),
+ self.getdict()]),
])
#already imported case
w_import = space.builtin.get('__import__')
More information about the Pypy-commit
mailing list