def __init__(self, space, w_name): def loader(myspace): assert myspace is space return myspace.wrap("hello") MixedModule.__init__(self, space, w_name) self.loaders["hi"] = loader
def __init__(self, space, w_name): def create_lambda(name, alsoname): return lambda space: self.getdictvalue(space, alsoname) MixedModule.__init__(self, space, w_name) for name, alsoname in self.mapping.iteritems(): self.loaders[name] = create_lambda(name, alsoname)
def __init__(self, space, *args): "NOT_RPYTHON: patches space.threadlocals to use real threadlocals" from pypy.module.thread import gil MixedModule.__init__(self, space, *args) prev = space.threadlocals.getvalue() space.threadlocals = gil.GILThreadLocals() space.threadlocals.setvalue(prev)
def __init__(self, space, w_name): def loader(myspace): assert myspace is space return myspace.wrap("hello") MixedModule.__init__(self, space, w_name) self.loaders["hi"] = loader
def __init__(self, space, *args): "NOT_RPYTHON: patches space.threadlocals to use real threadlocals" from pypy.module.thread import gil MixedModule.__init__(self, space, *args) prev = space.threadlocals.getvalue() space.threadlocals = gil.GILThreadLocals() space.threadlocals.setvalue(prev)
def __init__(self, space, w_name): def create_lambda(name, alsoname): return lambda space : self.getdictvalue(space, space.wrap(alsoname)) MixedModule.__init__(self, space, w_name) for name, alsoname in self.mapping.iteritems(): self.loaders[name] = create_lambda(name, alsoname)
def __init__(self, space, w_name): backend = space.config.translation.backend # the Win32 urandom implementation isn't going to translate on JVM or CLI # so we have to remove it if 'urandom' in self.interpleveldefs and (backend == 'cli' or backend == 'jvm'): del self.interpleveldefs['urandom'] MixedModule.__init__(self, space, w_name)
def __init__(self, space, *args): MixedModule.__init__(self, space, *args) # if not space.config.objspace.disable_entrypoints: # import 'embedding', which has the side-effect of registering # the 'pypy_init_embedded_cffi_module' entry point from pypy.module._cffi_backend import embedding embedding.glob.space = space
def __init__(self, space, *args): "NOT_RPYTHON" MixedModule.__init__(self, space, *args) # pythonization functions may be written in RPython, but the interp2app # code generation is not, so give it a chance to run now from pypy.module.cppyy import capi capi.register_pythonizations(space)
def __init__(self, space, *args): "NOT_RPYTHON" MixedModule.__init__(self, space, *args) from pypy.module.posix.interp_posix import add_fork_hook from pypy.module.imp import interp_imp add_fork_hook('before', interp_imp.acquire_lock) add_fork_hook('parent', interp_imp.release_lock) add_fork_hook('child', interp_imp.reinit_lock)
def __init__(self, space, w_name): # if it's an ootype translation, remove all the defs that are lltype # only backend = space.config.translation.backend if backend == "cli" or backend == "jvm": for name in lltype_only_defs: self.interpleveldefs.pop(name, None) MixedModule.__init__(self, space, w_name)
def __init__(self, space, *args): "NOT_RPYTHON" MixedModule.__init__(self, space, *args) # pythonization functions may be written in RPython, but the interp2app # code generation is not, so give it a chance to run now from pypy.module.cppyy import capi capi.register_pythonizations(space)
def __init__(self, space, w_name): # if it's an ootype translation, remove all the defs that are lltype # only backend = space.config.translation.backend if backend == 'cli' or backend == 'jvm': for name in lltype_only_defs: self.interpleveldefs.pop(name, None) MixedModule.__init__(self, space, w_name)
def __init__(self, space, *args): "NOT_RPYTHON" MixedModule.__init__(self, space, *args) from pypy.module.posix.interp_posix import add_fork_hook from pypy.module.imp import interp_imp add_fork_hook('before', interp_imp.acquire_lock) add_fork_hook('parent', interp_imp.release_lock) add_fork_hook('child', interp_imp.reinit_lock)
def __init__(self, space, *args): # mbcs codec is Windows specific, and based on rffi. if (hasattr(runicode, 'str_decode_mbcs')): self.interpleveldefs['mbcs_encode'] = 'interp_codecs.mbcs_encode' self.interpleveldefs['mbcs_decode'] = 'interp_codecs.mbcs_decode' MixedModule.__init__(self, space, *args) interp_codecs.register_builtin_error_handlers(space)
def __init__(self, space, *args): "NOT_RPYTHON" from pypy.module.signal import interp_signal MixedModule.__init__(self, space, *args) # add the signal-checking callback as an action on the space space.check_signal_action = interp_signal.CheckSignalAction(space) space.actionflag.register_periodic_action(space.check_signal_action, use_bytecode_counter=False) space.actionflag.__class__ = interp_signal.SignalActionFlag
def init(self, space): MixedModule.init(self, space) w_UnsupportedOperation = space.call_function( space.w_type, space.wrap('UnsupportedOperation'), space.newtuple([space.w_ValueError, space.w_IOError]), space.newdict()) space.setattr(self, space.wrap('UnsupportedOperation'), w_UnsupportedOperation)
def __init__(self, space, *args): "NOT_RPYTHON" from pypy.module.signal import interp_signal MixedModule.__init__(self, space, *args) # add the signal-checking callback as an action on the space space.check_signal_action = interp_signal.CheckSignalAction(space) space.actionflag.register_periodic_action(space.check_signal_action, use_bytecode_counter=False) space.actionflag.__class__ = interp_signal.SignalActionFlag
def __init__(self, space, *args): "NOT_RPYTHON" # mbcs codec is Windows specific, and based on rffi. if (hasattr(runicode, 'str_decode_mbcs') and space.config.translation.type_system != 'ootype'): self.interpleveldefs['mbcs_encode'] = 'interp_codecs.mbcs_encode' self.interpleveldefs['mbcs_decode'] = 'interp_codecs.mbcs_decode' MixedModule.__init__(self, space, *args)
def __init__(self, space, *args): "NOT_RPYTHON: patches space.threadlocals to use real threadlocals" from pypy.module.thread import gil MixedModule.__init__(self, space, *args) prev = space.threadlocals.getvalue() space.threadlocals = gil.GILThreadLocals() space.threadlocals.setvalue(prev) space.threadlocals.enter_thread(space) # setup the main thread # add the GIL-releasing callback as an action on the space space.pending_actions.append(gil.GILReleaseAction(space.threadlocals))
def __init__(self, space, *args): "NOT_RPYTHON" # mbcs codec is Windows specific, and based on rffi. if (hasattr(runicode, 'str_decode_mbcs') and space.config.translation.type_system != 'ootype'): self.interpleveldefs['mbcs_encode'] = 'interp_codecs.mbcs_encode' self.interpleveldefs['mbcs_decode'] = 'interp_codecs.mbcs_decode' MixedModule.__init__(self, space, *args)
def __init__(self, space, *args): "NOT_RPYTHON" # mbcs codec is Windows specific, and based on rffi. if (hasattr(runicode, 'str_decode_mbcs')): self.interpleveldefs['mbcs_encode'] = 'interp_codecs.mbcs_encode' self.interpleveldefs['mbcs_decode'] = 'interp_codecs.mbcs_decode' MixedModule.__init__(self, space, *args) interp_codecs.register_builtin_error_handlers(space)
def __init__(self, space, *args): "NOT_RPYTHON" # on windows with oo backends, remove file.truncate, # because the implementation is based on rffi if (sys.platform == 'win32' and space.config.translation.type_system == 'ootype'): from pypy.module._file.interp_file import W_File del W_File.typedef.rawdict['truncate'] MixedModule.__init__(self, space, *args)
def __init__(self, space, *args): "NOT_RPYTHON" # on windows with oo backends, remove file.truncate, # because the implementation is based on rffi if (sys.platform == 'win32' and space.config.translation.type_system == 'ootype'): from pypy.module._file.interp_file import W_File del W_File.typedef.rawdict['truncate'] MixedModule.__init__(self, space, *args)
def __init__(self, space, *args): "NOT_RPYTHON" from pypy.module.signal import interp_signal MixedModule.__init__(self, space, *args) # add the signal-checking callback as an action on the space space.check_signal_action = interp_signal.CheckSignalAction(space) space.actionflag.register_action(space.check_signal_action) # use the C-level pypysig_occurred variable as the action flag # (the result is that the C-level signal handler will directly # set the flag for the CheckSignalAction) space.actionflag.__class__ = interp_signal.SignalActionFlag
def __init__(self, space, *args): "NOT_RPYTHON: patches space.threadlocals to use real threadlocals" from pypy.module.thread import gil MixedModule.__init__(self, space, *args) prev = space.threadlocals.getvalue() space.threadlocals = gil.GILThreadLocals() space.threadlocals.initialize(space) space.threadlocals.setvalue(prev) from pypy.module.posix.interp_posix import add_fork_hook from pypy.module.thread.os_thread import reinit_threads add_fork_hook('child', reinit_threads)
def __init__(self, space, *args): "NOT_RPYTHON: patches space.threadlocals to use real threadlocals" from pypy.module.thread import gil MixedModule.__init__(self, space, *args) prev = space.threadlocals.getvalue() space.threadlocals = gil.GILThreadLocals() space.threadlocals.initialize(space) space.threadlocals.setvalue(prev) from pypy.module.posix.interp_posix import add_fork_hook from pypy.module.thread.os_thread import reinit_threads add_fork_hook('child', reinit_threads)
def __init__(self, space, *args): # mbcs codec is Windows specific, and based on rffi system calls. if rwin32.WIN32: self.interpleveldefs['mbcs_encode'] = 'interp_codecs.mbcs_encode' self.interpleveldefs['oem_encode'] = 'interp_codecs.oem_encode' self.interpleveldefs['code_page_encode'] = 'interp_codecs.code_page_encode' self.interpleveldefs['mbcs_decode'] = 'interp_codecs.mbcs_decode' self.interpleveldefs['oem_decode'] = 'interp_codecs.oem_decode' self.interpleveldefs['code_page_decode'] = 'interp_codecs.code_page_decode' MixedModule.__init__(self, space, *args) interp_codecs.register_builtin_error_handlers(space)
def getdictvalue(self, space, w_attr): """ specialize access to dynamic exc_* attributes. """ value = MixedModule.getdictvalue(self, space, w_attr) if value is not None: return value attr = space.str_w(w_attr) if attr == 'exc_type': operror = space.getexecutioncontext().sys_exc_info() if operror is None: return space.w_None else: return operror.w_type elif attr == 'exc_value': operror = space.getexecutioncontext().sys_exc_info() if operror is None: return space.w_None else: return operror.w_value elif attr == 'exc_traceback': operror = space.getexecutioncontext().sys_exc_info() if operror is None: return space.w_None else: return space.wrap(operror.application_traceback) return None
def getdictvalue(self, space, w_attr): """ specialize access to dynamic exc_* attributes. """ value = MixedModule.getdictvalue(self, space, w_attr) if value is not None: return value attr = space.str_w(w_attr) if attr == 'exc_type': operror = space.getexecutioncontext().sys_exc_info() if operror is None: return space.w_None else: return operror.w_type elif attr == 'exc_value': operror = space.getexecutioncontext().sys_exc_info() if operror is None: return space.w_None else: return operror.w_value elif attr == 'exc_traceback': operror = space.getexecutioncontext().sys_exc_info() if operror is None: return space.w_None else: return space.wrap(operror.application_traceback) return None
def __init__(self, space, w_name): if (not space.config.translating or space.config.translation.gctransformer == "framework"): self.appleveldefs.update({ 'dump_rpy_heap': 'app_referents.dump_rpy_heap', }) self.interpleveldefs.update({ 'get_rpy_roots': 'referents.get_rpy_roots', 'get_rpy_referents': 'referents.get_rpy_referents', 'get_rpy_memory_usage': 'referents.get_rpy_memory_usage', 'get_rpy_type_index': 'referents.get_rpy_type_index', 'get_objects': 'referents.get_objects', 'get_referents': 'referents.get_referents', 'get_referrers': 'referents.get_referrers', '_dump_rpy_heap': 'referents._dump_rpy_heap', 'get_typeids_z': 'referents.get_typeids_z', 'GcRef': 'referents.W_GcRef', }) MixedModule.__init__(self, space, w_name)
def __init__(self, space, w_name): if (not space.config.translating or space.config.translation.gctransformer == "framework"): self.appleveldefs.update({ 'dump_rpy_heap': 'app_referents.dump_rpy_heap', }) self.interpleveldefs.update({ 'get_rpy_roots': 'referents.get_rpy_roots', 'get_rpy_referents': 'referents.get_rpy_referents', 'get_rpy_memory_usage': 'referents.get_rpy_memory_usage', 'get_rpy_type_index': 'referents.get_rpy_type_index', 'get_objects': 'referents.get_objects', 'get_referents': 'referents.get_referents', 'get_referrers': 'referents.get_referrers', '_dump_rpy_heap': 'referents._dump_rpy_heap', 'get_typeids_z': 'referents.get_typeids_z', 'GcRef': 'referents.W_GcRef', }) MixedModule.__init__(self, space, w_name)
def __init__(self, space, w_name): if (not space.config.translating or space.config.translation.gctransformer == "framework"): self.appleveldefs.update({ 'dump_rpy_heap': 'app_referents.dump_rpy_heap', 'get_stats': 'app_referents.get_stats', }) self.interpleveldefs.update({ 'collect_step': 'interp_gc.collect_step', 'get_rpy_roots': 'referents.get_rpy_roots', 'get_rpy_referents': 'referents.get_rpy_referents', 'get_rpy_memory_usage': 'referents.get_rpy_memory_usage', 'get_rpy_type_index': 'referents.get_rpy_type_index', 'get_objects': 'referents.get_objects', 'get_referents': 'referents.get_referents', 'get_referrers': 'referents.get_referrers', '_get_stats': 'referents.get_stats', '_dump_rpy_heap': 'referents._dump_rpy_heap', 'get_typeids_z': 'referents.get_typeids_z', 'get_typeids_list': 'referents.get_typeids_list', 'GcRef': 'referents.W_GcRef', 'hooks': 'space.fromcache(hook.W_AppLevelHooks)', 'GcCollectStepStats': 'hook.W_GcCollectStepStats', }) MixedModule.__init__(self, space, w_name)
def getdictvalue(self, space, attr): """ specialize access to dynamic exc_* attributes. """ value = MixedModule.getdictvalue(self, space, attr) if value is not None: return value if attr == "exc_type": operror = space.getexecutioncontext().sys_exc_info() if operror is None: return space.w_None else: return operror.w_type elif attr == "exc_value": operror = space.getexecutioncontext().sys_exc_info() if operror is None: return space.w_None else: return operror.get_w_value(space) elif attr == "exc_traceback": operror = space.getexecutioncontext().sys_exc_info() if operror is None: return space.w_None else: return space.wrap(operror.get_traceback()) return None
def shutdown(self, space): from pypy.module.faulthandler import handler handler.finish(space) MixedModule.shutdown(self, space)
def __init__(self, space, w_name): MixedModule.__init__(self, space, w_name) _init_symbols(space.config.objspace.pyversion)
def init(self, space): MixedModule.init(self, space) from pypy.module._multiprocessing.interp_connection import State space.fromcache(State).init(space)
def init(self, space): MixedModule.init(self, space) from pypy.module._multiprocessing.interp_connection import State space.fromcache(State).init(space)
def __init__(self, space, w_name): ts = space.config.translation.type_system if ts == 'ootype': del self.interpleveldefs['dump_heap_stats'] MixedModule.__init__(self, space, w_name)
def __init__(self, space, *args): "NOT_RPYTHON" from pypy.module.signal.interp_signal import CheckSignalAction MixedModule.__init__(self, space, *args) # add the signal-checking callback as an action on the space space.pending_actions.append(CheckSignalAction(space))
def __init__(self, space, w_name): ts = space.config.translation.type_system if ts == 'ootype': del self.interpleveldefs['dump_heap_stats'] MixedModule.__init__(self, space, w_name)