[pypy-commit] pypy improve-rbigint: Merge default
stian
noreply at buildbot.pypy.org
Sat Jul 21 18:42:04 CEST 2012
Author: stian
Branch: improve-rbigint
Changeset: r56371:3c2823f1088c
Date: 2012-07-18 23:50 +0200
http://bitbucket.org/pypy/pypy/changeset/3c2823f1088c/
Log: Merge default
diff --git a/lib_pypy/PyQt4.py b/lib_pypy/PyQt4.py
deleted file mode 100644
--- a/lib_pypy/PyQt4.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from _rpyc_support import proxy_sub_module, remote_eval
-
-
-for name in ("QtCore", "QtGui", "QtWebKit"):
- proxy_sub_module(globals(), name)
-
-s = "__import__('PyQt4').QtGui.QDialogButtonBox."
-QtGui.QDialogButtonBox.Cancel = remote_eval("%sCancel | %sCancel" % (s, s))
-QtGui.QDialogButtonBox.Ok = remote_eval("%sOk | %sOk" % (s, s))
diff --git a/lib_pypy/_rpyc_support.py b/lib_pypy/_rpyc_support.py
deleted file mode 100644
--- a/lib_pypy/_rpyc_support.py
+++ /dev/null
@@ -1,24 +0,0 @@
-import sys
-import socket
-
-from rpyc import connect, SlaveService
-from rpyc.utils.classic import DEFAULT_SERVER_PORT
-
-try:
- conn = connect("localhost", DEFAULT_SERVER_PORT, SlaveService,
- config=dict(call_by_value_for_builtin_mutable_types=True))
-except socket.error, e:
- raise ImportError("Error while connecting: " + str(e))
-
-
-remote_eval = conn.eval
-
-
-def proxy_module(globals):
- module = getattr(conn.modules, globals["__name__"])
- for name in module.__dict__.keys():
- globals[name] = getattr(module, name)
-
-def proxy_sub_module(globals, name):
- fullname = globals["__name__"] + "." + name
- sys.modules[fullname] = globals[name] = conn.modules[fullname]
diff --git a/lib_pypy/distributed/__init__.py b/lib_pypy/distributed/__init__.py
deleted file mode 100644
--- a/lib_pypy/distributed/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-
-try:
- from protocol import RemoteProtocol, test_env, remote_loop, ObjectNotFound
-except ImportError:
- # XXX fix it
- # UGH. This is needed for tests
- pass
diff --git a/lib_pypy/distributed/demo/sockdemo.py b/lib_pypy/distributed/demo/sockdemo.py
deleted file mode 100644
--- a/lib_pypy/distributed/demo/sockdemo.py
+++ /dev/null
@@ -1,42 +0,0 @@
-
-from distributed import RemoteProtocol, remote_loop
-from distributed.socklayer import Finished, socket_listener, socket_connecter
-
-PORT = 12122
-
-class X:
- def __init__(self, z):
- self.z = z
-
- def meth(self, x):
- return self.z + x()
-
- def raising(self):
- 1/0
-
-x = X(3)
-
-def remote():
- send, receive = socket_listener(address=('', PORT))
- remote_loop(RemoteProtocol(send, receive, globals()))
-
-def local():
- send, receive = socket_connecter(('localhost', PORT))
- return RemoteProtocol(send, receive)
-
-import sys
-if __name__ == '__main__':
- if len(sys.argv) > 1 and sys.argv[1] == '-r':
- try:
- remote()
- except Finished:
- print "Finished"
- else:
- rp = local()
- x = rp.get_remote("x")
- try:
- x.raising()
- except:
- import sys
- import pdb
- pdb.post_mortem(sys.exc_info()[2])
diff --git a/lib_pypy/distributed/faker.py b/lib_pypy/distributed/faker.py
deleted file mode 100644
--- a/lib_pypy/distributed/faker.py
+++ /dev/null
@@ -1,89 +0,0 @@
-
-""" This file is responsible for faking types
-"""
-
-class GetSetDescriptor(object):
- def __init__(self, protocol, name):
- self.protocol = protocol
- self.name = name
-
- def __get__(self, obj, type=None):
- return self.protocol.get(self.name, obj, type)
-
- def __set__(self, obj, value):
- self.protocol.set(self.name, obj, value)
-
-class GetDescriptor(object):
- def __init__(self, protocol, name):
- self.protocol = protocol
- self.name = name
-
- def __get__(self, obj, type=None):
- return self.protocol.get(self.name, obj, type)
-
-# these are one-go functions for wrapping/unwrapping types,
-# note that actual caching is defined in other files,
-# this is only the case when we *need* to wrap/unwrap
-# type
-
-from types import MethodType, FunctionType
-
-def not_ignore(name):
- # we don't want to fake some default descriptors, because
- # they'll alter the way we set attributes
- l = ['__dict__', '__weakref__', '__class__', '__bases__',
- '__getattribute__', '__getattr__', '__setattr__',
- '__delattr__']
- return not name in dict.fromkeys(l)
-
-def wrap_type(protocol, tp, tp_id):
- """ Wrap type to transpotable entity, taking
- care about descriptors
- """
- dict_w = {}
- for item in tp.__dict__.keys():
- value = getattr(tp, item)
- if not_ignore(item):
- # we've got shortcut for method
- if hasattr(value, '__get__') and not type(value) is MethodType:
- if hasattr(value, '__set__'):
- dict_w[item] = ('get', item)
- else:
- dict_w[item] = ('set', item)
- else:
- dict_w[item] = protocol.wrap(value)
- bases_w = [protocol.wrap(i) for i in tp.__bases__ if i is not object]
- return tp_id, tp.__name__, dict_w, bases_w
-
-def unwrap_descriptor_gen(desc_class):
- def unwrapper(protocol, data):
- name = data
- obj = desc_class(protocol, name)
- obj.__name__ = name
- return obj
- return unwrapper
-
-unwrap_get_descriptor = unwrap_descriptor_gen(GetDescriptor)
-unwrap_getset_descriptor = unwrap_descriptor_gen(GetSetDescriptor)
-
-def unwrap_type(objkeeper, protocol, type_id, name_, dict_w, bases_w):
- """ Unwrap remote type, based on it's description
- """
- if bases_w == []:
- bases = (object,)
- else:
- bases = tuple([protocol.unwrap(i) for i in bases_w])
- d = dict.fromkeys(dict_w)
- # XXX we do it in two steps to avoid cyclic dependencies,
- # probably there is some smarter way of doing this
- if '__doc__' in dict_w:
- d['__doc__'] = protocol.unwrap(dict_w['__doc__'])
- tp = type(name_, bases, d)
- objkeeper.register_remote_type(tp, type_id)
- for key, value in dict_w.items():
- if key != '__doc__':
- v = protocol.unwrap(value)
- if isinstance(v, FunctionType):
- setattr(tp, key, staticmethod(v))
- else:
- setattr(tp, key, v)
diff --git a/lib_pypy/distributed/objkeeper.py b/lib_pypy/distributed/objkeeper.py
deleted file mode 100644
--- a/lib_pypy/distributed/objkeeper.py
+++ /dev/null
@@ -1,63 +0,0 @@
-
-""" objkeeper - Storage for remoteprotocol
-"""
-
-from types import FunctionType
-from distributed import faker
-
-class ObjKeeper(object):
- def __init__(self, exported_names = {}):
- self.exported_objects = [] # list of object that we've exported outside
- self.exported_names = exported_names # dictionary of visible objects
- self.exported_types = {} # dict of exported types
- self.remote_types = {}
- self.reverse_remote_types = {}
- self.remote_objects = {}
- self.exported_types_id = 0 # unique id of exported types
- self.exported_types_reverse = {} # reverse dict of exported types
-
- def register_object(self, obj):
- # XXX: At some point it makes sense not to export them again and again...
- self.exported_objects.append(obj)
- return len(self.exported_objects) - 1
-
- def ignore(self, key, value):
- # there are some attributes, which cannot be modified later, nor
- # passed into default values, ignore them
- if key in ('__dict__', '__weakref__', '__class__',
- '__dict__', '__bases__'):
- return True
- return False
-
- def register_type(self, protocol, tp):
- try:
- return self.exported_types[tp]
- except KeyError:
- self.exported_types[tp] = self.exported_types_id
- self.exported_types_reverse[self.exported_types_id] = tp
- tp_id = self.exported_types_id
- self.exported_types_id += 1
-
- protocol.send(('type_reg', faker.wrap_type(protocol, tp, tp_id)))
- return tp_id
-
- def fake_remote_type(self, protocol, tp_data):
- type_id, name_, dict_w, bases_w = tp_data
- tp = faker.unwrap_type(self, protocol, type_id, name_, dict_w, bases_w)
-
- def register_remote_type(self, tp, type_id):
- self.remote_types[type_id] = tp
- self.reverse_remote_types[tp] = type_id
-
- def get_type(self, id):
- return self.remote_types[id]
-
- def get_object(self, id):
- return self.exported_objects[id]
-
- def register_remote_object(self, controller, id):
- self.remote_objects[controller] = id
-
- def get_remote_object(self, controller):
- return self.remote_objects[controller]
-
diff --git a/lib_pypy/distributed/protocol.py b/lib_pypy/distributed/protocol.py
deleted file mode 100644
--- a/lib_pypy/distributed/protocol.py
+++ /dev/null
@@ -1,447 +0,0 @@
-
-""" Distributed controller(s) for use with transparent proxy objects
-
-First idea:
-
-1. We use py.execnet to create a connection to wherever
-2. We run some code there (RSync in advance makes some sense)
-3. We access remote objects like normal ones, with a special protocol
-
-Local side:
- - Request an object from remote side from global namespace as simple
- --- request(name) --->
- - Receive an object which is in protocol described below which is
- constructed as shallow copy of the remote type.
-
- Shallow copy is defined as follows:
-
- - for interp-level object that we know we can provide transparent proxy
- we just do that
-
- - for others we fake or fail depending on object
-
- - for user objects, we create a class which fakes all attributes of
- a class as transparent proxies of remote objects, we create an instance
- of that class and populate __dict__
-
- - for immutable types, we just copy that
-
-Remote side:
- - we run code, whatever we like
- - additionally, we've got thread exporting stuff (or just exporting
- globals, whatever)
- - for every object, we just send an object, or provide a protocol for
- sending it in a different way.
-
-"""
-
-try:
- from __pypy__ import tproxy as proxy
- from __pypy__ import get_tproxy_controller
-except ImportError:
- raise ImportError("Cannot work without transparent proxy functionality")
-
-from distributed.objkeeper import ObjKeeper
-from distributed import faker
-import sys
-
-class ObjectNotFound(Exception):
- pass
-
-# XXX We do not make any garbage collection. We'll need it at some point
-
-"""
-TODO list:
-
-1. Garbage collection - we would like probably to use weakrefs, but
- since they're not perfectly working in pypy, let's leave it alone for now
-2. Some error handling - exceptions are working, there are still some
- applications where it all explodes.
-3. Support inheritance and recursive types
-"""
-
-from __pypy__ import internal_repr
-
-import types
-from marshal import dumps
-import exceptions
-
-# just placeholders for letter_types value
-class RemoteBase(object):
- pass
-
-class DataDescriptor(object):
- pass
-
-class NonDataDescriptor(object):
- pass
-# end of placeholders
-
-class AbstractProtocol(object):
- immutable_primitives = (str, int, float, long, unicode, bool, types.NotImplementedType)
- mutable_primitives = (list, dict, types.FunctionType, types.FrameType, types.TracebackType,
- types.CodeType)
- exc_dir = dict((val, name) for name, val in exceptions.__dict__.iteritems())
-
- letter_types = {
- 'l' : list,
- 'd' : dict,
- 'c' : types.CodeType,
- 't' : tuple,
- 'e' : Exception,
- 'ex': exceptions, # for instances
- 'i' : int,
- 'b' : bool,
- 'f' : float,
- 'u' : unicode,
- 'l' : long,
- 's' : str,
- 'ni' : types.NotImplementedType,
- 'n' : types.NoneType,
- 'lst' : list,
- 'fun' : types.FunctionType,
- 'cus' : object,
- 'meth' : types.MethodType,
- 'type' : type,
- 'tp' : None,
- 'fr' : types.FrameType,
- 'tb' : types.TracebackType,
- 'reg' : RemoteBase,
- 'get' : NonDataDescriptor,
- 'set' : DataDescriptor,
- }
- type_letters = dict([(value, key) for key, value in letter_types.items()])
- assert len(type_letters) == len(letter_types)
-
- def __init__(self, exported_names={}):
- self.keeper = ObjKeeper(exported_names)
- #self.remote_objects = {} # a dictionary controller --> id
- #self.objs = [] # we just store everything, maybe later
- # # we'll need some kind of garbage collection
-
- def wrap(self, obj):
- """ Wrap an object as sth prepared for sending
- """
- def is_element(x, iterable):
- try:
- return x in iterable
- except (TypeError, ValueError):
- return False
-
- tp = type(obj)
- ctrl = get_tproxy_controller(obj)
- if ctrl:
- return "tp", self.keeper.get_remote_object(ctrl)
- elif obj is None:
- return self.type_letters[tp]
- elif tp in self.immutable_primitives:
- # simple, immutable object, just copy
- return (self.type_letters[tp], obj)
- elif hasattr(obj, '__class__') and obj.__class__ in self.exc_dir:
- return (self.type_letters[Exception], (self.exc_dir[obj.__class__], \
- self.wrap(obj.args)))
- elif is_element(obj, self.exc_dir): # weird hashing problems
- return (self.type_letters[exceptions], self.exc_dir[obj])
- elif tp is tuple:
- # we just pack all of the items
- return ('t', tuple([self.wrap(elem) for elem in obj]))
- elif tp in self.mutable_primitives:
- id = self.keeper.register_object(obj)
- return (self.type_letters[tp], id)
- elif tp is type:
- try:
- return "reg", self.keeper.reverse_remote_types[obj]
- except KeyError:
- pass
- try:
- return self.type_letters[tp], self.type_letters[obj]
- except KeyError:
- id = self.register_type(obj)
- return (self.type_letters[tp], id)
- elif tp is types.MethodType:
- w_class = self.wrap(obj.im_class)
- w_func = self.wrap(obj.im_func)
- w_self = self.wrap(obj.im_self)
- return (self.type_letters[tp], (w_class, \
- self.wrap(obj.im_func.func_name), w_func, w_self))
- else:
- id = self.keeper.register_object(obj)
- w_tp = self.wrap(tp)
- return ("cus", (w_tp, id))
-
- def unwrap(self, data):
- """ Unwrap an object
- """
- if data == 'n':
- return None
- tp_letter, obj_data = data
- tp = self.letter_types[tp_letter]
- if tp is None:
- return self.keeper.get_object(obj_data)
- elif tp is RemoteBase:
- return self.keeper.exported_types_reverse[obj_data]
- elif tp in self.immutable_primitives:
- return obj_data # this is the object
- elif tp is tuple:
- return tuple([self.unwrap(i) for i in obj_data])
- elif tp in self.mutable_primitives:
- id = obj_data
- ro = RemoteBuiltinObject(self, id)
- self.keeper.register_remote_object(ro.perform, id)
- p = proxy(tp, ro.perform)
- ro.obj = p
- return p
- elif tp is Exception:
- cls_name, w_args = obj_data
- return getattr(exceptions, cls_name)(self.unwrap(w_args))
- elif tp is exceptions:
- cls_name = obj_data
- return getattr(exceptions, cls_name)
- elif tp is types.MethodType:
- w_class, w_name, w_func, w_self = obj_data
- tp = self.unwrap(w_class)
- name = self.unwrap(w_name)
- self_ = self.unwrap(w_self)
- if self_ is not None:
- if tp is None:
- setattr(self_, name, classmethod(self.unwrap(w_func)))
- return getattr(self_, name)
- return getattr(tp, name).__get__(self_, tp)
- func = self.unwrap(w_func)
- setattr(tp, name, func)
- return getattr(tp, name)
- elif tp is type:
- if isinstance(obj_data, str):
- return self.letter_types[obj_data]
- id = obj_data
- return self.get_type(obj_data)
- elif tp is DataDescriptor:
- return faker.unwrap_getset_descriptor(self, obj_data)
- elif tp is NonDataDescriptor:
- return faker.unwrap_get_descriptor(self, obj_data)
- elif tp is object:
- # we need to create a proper type
- w_tp, id = obj_data
- real_tp = self.unwrap(w_tp)
- ro = RemoteObject(self, id)
- self.keeper.register_remote_object(ro.perform, id)
- p = proxy(real_tp, ro.perform)
- ro.obj = p
- return p
- else:
- raise NotImplementedError("Cannot unwrap %s" % (data,))
-
- def perform(self, *args, **kwargs):
- raise NotImplementedError("Abstract only protocol")
-
- # some simple wrappers
- def pack_args(self, args, kwargs):
- return self.pack_list(args), self.pack_dict(kwargs)
-
- def pack_list(self, lst):
- return [self.wrap(i) for i in lst]
-
- def pack_dict(self, d):
- return dict([(self.wrap(key), self.wrap(val)) for key, val in d.items()])
-
- def unpack_args(self, args, kwargs):
- return self.unpack_list(args), self.unpack_dict(kwargs)
-
- def unpack_list(self, lst):
- return [self.unwrap(i) for i in lst]
-
- def unpack_dict(self, d):
- return dict([(self.unwrap(key), self.unwrap(val)) for key, val in d.items()])
-
- def register_type(self, tp):
- return self.keeper.register_type(self, tp)
-
- def get_type(self, id):
- return self.keeper.get_type(id)
-
-class LocalProtocol(AbstractProtocol):
- """ This is stupid protocol for testing purposes only
- """
- def __init__(self):
- super(LocalProtocol, self).__init__()
- self.types = []
-
- def perform(self, id, name, *args, **kwargs):
- obj = self.keeper.get_object(id)
- # we pack and than unpack, for tests
- args, kwargs = self.pack_args(args, kwargs)
- assert isinstance(name, str)
- dumps((args, kwargs))
- args, kwargs = self.unpack_args(args, kwargs)
- return getattr(obj, name)(*args, **kwargs)
-
- def register_type(self, tp):
- self.types.append(tp)
- return len(self.types) - 1
-
- def get_type(self, id):
- return self.types[id]
-
-def remote_loop(protocol):
- # the simplest version possible, without any concurrency and such
- wrap = protocol.wrap
- unwrap = protocol.unwrap
- send = protocol.send
- receive = protocol.receive
- # we need this for wrap/unwrap
- while 1:
- command, data = receive()
- if command == 'get':
- try:
- item = protocol.keeper.exported_names[data]
- except KeyError:
- send(("finished_error",data))
- else:
- # XXX wrapping problems catching? do we have any?
- send(("finished", wrap(item)))
- elif command == 'call':
- id, name, args, kwargs = data
- args, kwargs = protocol.unpack_args(args, kwargs)
- try:
- retval = getattr(protocol.keeper.get_object(id), name)(*args, **kwargs)
- except:
- send(("raised", wrap(sys.exc_info())))
- else:
- send(("finished", wrap(retval)))
- elif command == 'finished':
- return unwrap(data)
- elif command == 'finished_error':
- raise ObjectNotFound("Cannot find name %s" % (data,))
- elif command == 'raised':
- exc, val, tb = unwrap(data)
- raise exc, val, tb
- elif command == 'type_reg':
- protocol.keeper.fake_remote_type(protocol, data)
- elif command == 'force':
- obj = protocol.keeper.get_object(data)
- w_obj = protocol.pack(obj)
- send(("forced", w_obj))
- elif command == 'forced':
- obj = protocol.unpack(data)
- return obj
- elif command == 'desc_get':
- name, w_obj, w_type = data
- obj = protocol.unwrap(w_obj)
- type_ = protocol.unwrap(w_type)
- if obj:
- type__ = type(obj)
- else:
- type__ = type_
- send(('finished', protocol.wrap(getattr(type__, name).__get__(obj, type_))))
-
- elif command == 'desc_set':
- name, w_obj, w_value = data
- obj = protocol.unwrap(w_obj)
- value = protocol.unwrap(w_value)
- getattr(type(obj), name).__set__(obj, value)
- send(('finished', protocol.wrap(None)))
- elif command == 'remote_keys':
- keys = protocol.keeper.exported_names.keys()
- send(('finished', protocol.wrap(keys)))
- else:
- raise NotImplementedError("command %s" % command)
-
-class RemoteProtocol(AbstractProtocol):
- #def __init__(self, gateway, remote_code):
- # self.gateway = gateway
- def __init__(self, send, receive, exported_names={}):
- super(RemoteProtocol, self).__init__(exported_names)
- #self.exported_names = exported_names
- self.send = send
- self.receive = receive
- #self.type_cache = {}
- #self.type_id = 0
- #self.remote_types = {}
-
- def perform(self, id, name, *args, **kwargs):
- args, kwargs = self.pack_args(args, kwargs)
- self.send(('call', (id, name, args, kwargs)))
- try:
- retval = remote_loop(self)
- except:
- e, val, tb = sys.exc_info()
- raise e, val, tb.tb_next.tb_next
- return retval
-
- def get_remote(self, name):
- self.send(("get", name))
- retval = remote_loop(self)
- return retval
-
- def force(self, id):
- self.send(("force", id))
- retval = remote_loop(self)
- return retval
-
- def pack(self, obj):
- if isinstance(obj, list):
- return "l", self.pack_list(obj)
- elif isinstance(obj, dict):
- return "d", self.pack_dict(obj)
- else:
- raise NotImplementedError("Cannot pack %s" % obj)
-
- def unpack(self, data):
- letter, w_obj = data
- if letter == 'l':
- return self.unpack_list(w_obj)
- elif letter == 'd':
- return self.unpack_dict(w_obj)
- else:
- raise NotImplementedError("Cannot unpack %s" % (data,))
-
- def get(self, name, obj, type):
- self.send(("desc_get", (name, self.wrap(obj), self.wrap(type))))
- return remote_loop(self)
-
- def set(self, obj, value):
- self.send(("desc_set", (name, self.wrap(obj), self.wrap(value))))
-
- def remote_keys(self):
- self.send(("remote_keys",None))
- return remote_loop(self)
-
-class RemoteObject(object):
- def __init__(self, protocol, id):
- self.id = id
- self.protocol = protocol
-
- def perform(self, name, *args, **kwargs):
- return self.protocol.perform(self.id, name, *args, **kwargs)
-
-class RemoteBuiltinObject(RemoteObject):
- def __init__(self, protocol, id):
- self.id = id
- self.protocol = protocol
- self.forced = False
-
- def perform(self, name, *args, **kwargs):
- # XXX: Check who really goes here
- if self.forced:
- return getattr(self.obj, name)(*args, **kwargs)
- if name in ('__eq__', '__ne__', '__lt__', '__gt__', '__ge__', '__le__',
- '__cmp__'):
- self.obj = self.protocol.force(self.id)
- return getattr(self.obj, name)(*args, **kwargs)
- return self.protocol.perform(self.id, name, *args, **kwargs)
-
-def test_env(exported_names):
- from stackless import channel, tasklet, run
- inp, out = channel(), channel()
- remote_protocol = RemoteProtocol(inp.send, out.receive, exported_names)
- t = tasklet(remote_loop)(remote_protocol)
-
- #def send_trace(data):
- # print "Sending %s" % (data,)
- # out.send(data)
-
- #def receive_trace():
- # data = inp.receive()
- # print "Received %s" % (data,)
- # return data
- return RemoteProtocol(out.send, inp.receive)
diff --git a/lib_pypy/distributed/socklayer.py b/lib_pypy/distributed/socklayer.py
deleted file mode 100644
--- a/lib_pypy/distributed/socklayer.py
+++ /dev/null
@@ -1,83 +0,0 @@
-
-import py
-from socket import socket
-
-raise ImportError("XXX needs import adaptation as 'green' is removed from py lib for years")
-from py.impl.green.msgstruct import decodemessage, message
-from socket import socket, AF_INET, SOCK_STREAM
-import marshal
-import sys
-
-TRACE = False
-def trace(msg):
- if TRACE:
- print >>sys.stderr, msg
-
-class Finished(Exception):
- pass
-
-class SocketWrapper(object):
- def __init__(self, conn):
- self.buffer = ""
- self.conn = conn
-
-class ReceiverWrapper(SocketWrapper):
- def receive(self):
- msg, self.buffer = decodemessage(self.buffer)
- while msg is None:
- data = self.conn.recv(8192)
- if not data:
- raise Finished()
- self.buffer += data
- msg, self.buffer = decodemessage(self.buffer)
- assert msg[0] == 'c'
- trace("received %s" % msg[1])
- return marshal.loads(msg[1])
-
-class SenderWrapper(SocketWrapper):
- def send(self, data):
- trace("sending %s" % (data,))
- self.conn.sendall(message('c', marshal.dumps(data)))
- trace("done")
-
-def socket_listener(address, socket=socket):
- s = socket(AF_INET, SOCK_STREAM)
- s.bind(address)
- s.listen(1)
- print "Waiting for connection on %s" % (address,)
- conn, addr = s.accept()
- print "Connected from %s" % (addr,)
-
- return SenderWrapper(conn).send, ReceiverWrapper(conn).receive
-
-def socket_loop(address, to_export, socket=socket):
- from distributed import RemoteProtocol, remote_loop
- try:
- send, receive = socket_listener(address, socket)
- remote_loop(RemoteProtocol(send, receive, to_export))
- except Finished:
- pass
-
-def socket_connecter(address, socket=socket):
- s = socket(AF_INET, SOCK_STREAM)
- print "Connecting %s" % (address,)
- s.connect(address)
-
- return SenderWrapper(s).send, ReceiverWrapper(s).receive
-
-def connect(address, socket=socket):
- from distributed.support import RemoteView
- from distributed import RemoteProtocol
- return RemoteView(RemoteProtocol(*socket_connecter(address, socket)))
-
-def spawn_remote_side(code, gw):
- """ A very simple wrapper around greenexecnet to allow
- spawning a remote side of lib/distributed
- """
- from distributed import RemoteProtocol
- extra = str(py.code.Source("""
- from distributed import remote_loop, RemoteProtocol
- remote_loop(RemoteProtocol(channel.send, channel.receive, globals()))
- """))
- channel = gw.remote_exec(code + "\n" + extra)
- return RemoteProtocol(channel.send, channel.receive)
diff --git a/lib_pypy/distributed/support.py b/lib_pypy/distributed/support.py
deleted file mode 100644
--- a/lib_pypy/distributed/support.py
+++ /dev/null
@@ -1,17 +0,0 @@
-
-""" Some random support functions
-"""
-
-from distributed.protocol import ObjectNotFound
-
-class RemoteView(object):
- def __init__(self, protocol):
- self.__dict__['__protocol'] = protocol
-
- def __getattr__(self, name):
- if name == '__dict__':
- return super(RemoteView, self).__getattr__(name)
- try:
- return self.__dict__['__protocol'].get_remote(name)
- except ObjectNotFound:
- raise AttributeError(name)
diff --git a/lib_pypy/distributed/test/__init__.py b/lib_pypy/distributed/test/__init__.py
deleted file mode 100644
diff --git a/lib_pypy/distributed/test/test_distributed.py b/lib_pypy/distributed/test/test_distributed.py
deleted file mode 100644
--- a/lib_pypy/distributed/test/test_distributed.py
+++ /dev/null
@@ -1,301 +0,0 @@
-
-""" Controllers tests
-"""
-
-from pypy.conftest import gettestobjspace
-import sys
-import pytest
-
-class AppTestDistributed(object):
- def setup_class(cls):
- cls.space = gettestobjspace(**{"objspace.std.withtproxy": True,
- "usemodules":("_continuation",)})
-
- def test_init(self):
- import distributed
-
- def test_protocol(self):
- from distributed.protocol import AbstractProtocol
- protocol = AbstractProtocol()
- for item in ("aaa", 3, u"aa", 344444444444444444L, 1.2, (1, "aa")):
- assert protocol.unwrap(protocol.wrap(item)) == item
- assert type(protocol.unwrap(protocol.wrap([1,2,3]))) is list
- assert type(protocol.unwrap(protocol.wrap({"a":3}))) is dict
-
- def f():
- pass
-
- assert type(protocol.unwrap(protocol.wrap(f))) is type(f)
-
- def test_method_of_false_obj(self):
- from distributed.protocol import AbstractProtocol
- protocol = AbstractProtocol()
- lst = []
- m = lst.append
- assert type(protocol.unwrap(protocol.wrap(m))) is type(m)
-
- def test_protocol_run(self):
- l = [1,2,3]
- from distributed.protocol import LocalProtocol
- protocol = LocalProtocol()
- wrap = protocol.wrap
- unwrap = protocol.unwrap
- item = unwrap(wrap(l))
- assert len(item) == 3
- assert item[2] == 3
- item += [1,1,1]
- assert len(item) == 6
-
- def test_protocol_call(self):
- def f(x, y):
- return x + y
-
- from distributed.protocol import LocalProtocol
- protocol = LocalProtocol()
- wrap = protocol.wrap
- unwrap = protocol.unwrap
- item = unwrap(wrap(f))
- assert item(3, 2) == 5
-
- def test_simulation_call(self):
- def f(x, y):
- return x + y
-
- import types
- from distributed import RemoteProtocol
- import sys
-
- data = []
- result = []
- protocol = RemoteProtocol(result.append, data.pop)
- data += [("finished", protocol.wrap(5)), ("finished", protocol.wrap(f))]
- fun = protocol.get_remote("f")
- assert isinstance(fun, types.FunctionType)
- assert fun(2, 3) == 5
-
- def test_local_obj(self):
- class A(object):
- def __init__(self, x):
- self.x = x
-
- def __len__(self):
- return self.x + 8
-
- from distributed.protocol import LocalProtocol
- protocol = LocalProtocol()
- wrap = protocol.wrap
- unwrap = protocol.unwrap
- item = unwrap(wrap(A(3)))
- assert item.x == 3
- assert len(item) == 11
-
-class AppTestDistributedTasklets(object):
- spaceconfig = {"objspace.std.withtproxy": True,
- "objspace.usemodules._continuation": True}
- def setup_class(cls):
- cls.w_test_env = cls.space.appexec([], """():
- from distributed import test_env
- return test_env
- """)
- cls.reclimit = sys.getrecursionlimit()
- sys.setrecursionlimit(100000)
-
- def teardown_class(cls):
- sys.setrecursionlimit(cls.reclimit)
-
- def test_remote_protocol_call(self):
- def f(x, y):
- return x + y
-
- protocol = self.test_env({"f": f})
- fun = protocol.get_remote("f")
- assert fun(2, 3) == 5
-
- def test_callback(self):
- def g():
- return 8
-
- def f(x):
- return x + g()
-
- protocol = self.test_env({"f":f})
- fun = protocol.get_remote("f")
- assert fun(8) == 16
-
- def test_remote_dict(self):
- #skip("Land of infinite recursion")
- d = {'a':3}
- protocol = self.test_env({'d':d})
- xd = protocol.get_remote('d')
- #assert d['a'] == xd['a']
- assert d.keys() == xd.keys()
- assert d.values() == xd.values()
- assert d == xd
-
- def test_remote_obj(self):
- class A(object):
- def __init__(self, x):
- self.x = x
-
- def __len__(self):
- return self.x + 8
- a = A(3)
-
- protocol = self.test_env({'a':a})
- xa = protocol.get_remote("a")
- assert xa.x == 3
- assert len(xa) == 11
-
- def test_remote_doc_and_callback(self):
- class A(object):
- """xxx"""
- def __init__(self):
- pass
-
- def meth(self, x):
- return x() + 3
-
- def x():
- return 1
-
- a = A()
-
- protocol = self.test_env({'a':a})
- xa = protocol.get_remote('a')
- assert xa.__class__.__doc__ == 'xxx'
- assert xa.meth(x) == 4
-
- def test_double_reference(self):
- class A(object):
- def meth(self, one):
- self.one = one
-
- def perform(self):
- return 1 + len(self.one())
-
- class B(object):
- def __call__(self):
- return [1,2,3]
-
- a = A()
- protocol = self.test_env({'a': a})
- xa = protocol.get_remote('a')
- xa.meth(B())
- assert xa.perform() == 4
-
- def test_frame(self):
- #skip("Land of infinite recursion")
- import sys
- f = sys._getframe()
- protocol = self.test_env({'f':f})
- xf = protocol.get_remote('f')
- assert f.f_globals.keys() == xf.f_globals.keys()
- assert f.f_locals.keys() == xf.f_locals.keys()
-
- def test_remote_exception(self):
- def raising():
- 1/0
-
- protocol = self.test_env({'raising':raising})
- xr = protocol.get_remote('raising')
- try:
- xr()
- except ZeroDivisionError:
- import sys
- exc_info, val, tb = sys.exc_info()
- #assert tb.tb_next is None
- else:
- raise AssertionError("Did not raise")
-
- def test_remote_classmethod(self):
- class A(object):
- z = 8
-
- @classmethod
- def x(cls):
- return cls.z
-
- a = A()
- protocol = self.test_env({'a':a})
- xa = protocol.get_remote("a")
- res = xa.x()
- assert res == 8
-
- def test_types_reverse_mapping(self):
- class A(object):
- def m(self, tp):
- assert type(self) is tp
-
- a = A()
- protocol = self.test_env({'a':a, 'A':A})
- xa = protocol.get_remote('a')
- xA = protocol.get_remote('A')
- xa.m(xA)
-
- def test_instantiate_remote_type(self):
- class C(object):
- def __init__(self, y):
- self.y = y
-
- def x(self):
- return self.y
-
- protocol = self.test_env({'C':C})
- xC = protocol.get_remote('C')
- xc = xC(3)
- res = xc.x()
- assert res == 3
-
- def test_remote_sys(self):
- import sys
-
- protocol = self.test_env({'sys':sys})
- s = protocol.get_remote('sys')
- l = dir(s)
- assert l
-
- def test_remote_file_access(self):
- skip("Descriptor logic seems broken")
- protocol = self.test_env({'f':open})
- xf = protocol.get_remote('f')
- data = xf('/etc/passwd').read()
- assert data
-
- def test_real_descriptor(self):
- class getdesc(object):
- def __get__(self, obj, val=None):
- if obj is not None:
- assert type(obj) is X
- return 3
-
- class X(object):
- x = getdesc()
-
- x = X()
-
- protocol = self.test_env({'x':x})
- xx = protocol.get_remote('x')
- assert xx.x == 3
-
- def test_bases(self):
- class X(object):
- pass
-
- class Y(X):
- pass
-
- y = Y()
- protocol = self.test_env({'y':y, 'X':X})
- xy = protocol.get_remote('y')
- xX = protocol.get_remote('X')
- assert isinstance(xy, xX)
-
- def test_key_error(self):
- from distributed import ObjectNotFound
- protocol = self.test_env({})
- raises(ObjectNotFound, "protocol.get_remote('x')")
-
- def test_list_items(self):
- protocol = self.test_env({'x':3, 'y':8})
- assert sorted(protocol.remote_keys()) == ['x', 'y']
-
diff --git a/lib_pypy/distributed/test/test_greensock.py b/lib_pypy/distributed/test/test_greensock.py
deleted file mode 100644
--- a/lib_pypy/distributed/test/test_greensock.py
+++ /dev/null
@@ -1,62 +0,0 @@
-
-import py
-from pypy.conftest import gettestobjspace, option
-
-def setup_module(mod):
- py.test.importorskip("pygreen") # found e.g. in py/trunk/contrib
-
-class AppTestDistributedGreensock(object):
- def setup_class(cls):
- if not option.runappdirect:
- py.test.skip("Cannot run this on top of py.py because of PopenGateway")
- cls.space = gettestobjspace(**{"objspace.std.withtproxy": True,
- "usemodules":("_continuation",)})
- cls.w_remote_side_code = cls.space.appexec([], """():
- import sys
- sys.path.insert(0, '%s')
- remote_side_code = '''
-class A:
- def __init__(self, x):
- self.x = x
-
- def __len__(self):
- return self.x + 8
-
- def raising(self):
- 1/0
-
- def method(self, x):
- return x() + self.x
-
-a = A(3)
-
-def count():
- x = 10
- # naive counting :)
- result = 1
- for i in range(x):
- result += 1
- return result
-'''
- return remote_side_code
- """ % str(py.path.local(__file__).dirpath().dirpath().dirpath().dirpath()))
-
- def test_remote_call(self):
- from distributed import socklayer
- import sys
- from pygreen.greenexecnet import PopenGateway
- gw = PopenGateway()
- rp = socklayer.spawn_remote_side(self.remote_side_code, gw)
- a = rp.get_remote("a")
- assert a.method(lambda : 13) == 16
-
- def test_remote_counting(self):
- from distributed import socklayer
- from pygreen.greensock2 import allof
- from pygreen.greenexecnet import PopenGateway
- gws = [PopenGateway() for i in range(3)]
- rps = [socklayer.spawn_remote_side(self.remote_side_code, gw)
- for gw in gws]
- counters = [rp.get_remote("count") for rp in rps]
- assert allof(*counters) == (11, 11, 11)
-
diff --git a/lib_pypy/distributed/test/test_socklayer.py b/lib_pypy/distributed/test/test_socklayer.py
deleted file mode 100644
--- a/lib_pypy/distributed/test/test_socklayer.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import py
-from pypy.conftest import gettestobjspace
-
-def setup_module(mod):
- py.test.importorskip("pygreen") # found e.g. in py/trunk/contrib
-
-# XXX think how to close the socket
-
-class AppTestSocklayer:
- def setup_class(cls):
- cls.space = gettestobjspace(**{"objspace.std.withtproxy": True,
- "usemodules":("_continuation",
- "_socket", "select")})
-
- def test_socklayer(self):
- class X(object):
- z = 3
-
- x = X()
-
- try:
- import py
- except ImportError:
- skip("pylib not importable")
- from pygreen.pipe.gsocke import GreenSocket
- from distributed.socklayer import socket_loop, connect
- from pygreen.greensock2 import oneof, allof
-
- def one():
- socket_loop(('127.0.0.1', 21211), {'x':x}, socket=GreenSocket)
-
- def two():
- rp = connect(('127.0.0.1', 21211), GreenSocket)
- assert rp.x.z == 3
-
- oneof(one, two)
diff --git a/lib_pypy/sip.py b/lib_pypy/sip.py
deleted file mode 100644
--- a/lib_pypy/sip.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from _rpyc_support import proxy_module
-
-proxy_module(globals())
-del proxy_module
diff --git a/pypy/annotation/binaryop.py b/pypy/annotation/binaryop.py
--- a/pypy/annotation/binaryop.py
+++ b/pypy/annotation/binaryop.py
@@ -7,7 +7,7 @@
from pypy.tool.pairtype import pair, pairtype
from pypy.annotation.model import SomeObject, SomeInteger, SomeBool, s_Bool
from pypy.annotation.model import SomeString, SomeChar, SomeList, SomeDict
-from pypy.annotation.model import SomeUnicodeCodePoint
+from pypy.annotation.model import SomeUnicodeCodePoint, SomeStringOrUnicode
from pypy.annotation.model import SomeTuple, SomeImpossibleValue, s_ImpossibleValue
from pypy.annotation.model import SomeInstance, SomeBuiltin, SomeIterator
from pypy.annotation.model import SomePBC, SomeFloat, s_None
@@ -470,30 +470,37 @@
"string formatting mixing strings and unicode not supported")
-class __extend__(pairtype(SomeString, SomeTuple)):
- def mod((str, s_tuple)):
+class __extend__(pairtype(SomeString, SomeTuple),
+ pairtype(SomeUnicodeString, SomeTuple)):
+ def mod((s_string, s_tuple)):
+ is_string = isinstance(s_string, SomeString)
+ is_unicode = isinstance(s_string, SomeUnicodeString)
+ assert is_string or is_unicode
for s_item in s_tuple.items:
- if isinstance(s_item, (SomeUnicodeCodePoint, SomeUnicodeString)):
+ if (is_unicode and isinstance(s_item, (SomeChar, SomeString)) or
+ is_string and isinstance(s_item, (SomeUnicodeCodePoint,
+ SomeUnicodeString))):
raise NotImplementedError(
"string formatting mixing strings and unicode not supported")
- getbookkeeper().count('strformat', str, s_tuple)
- no_nul = str.no_nul
+ getbookkeeper().count('strformat', s_string, s_tuple)
+ no_nul = s_string.no_nul
for s_item in s_tuple.items:
if isinstance(s_item, SomeFloat):
pass # or s_item is a subclass, like SomeInteger
- elif isinstance(s_item, SomeString) and s_item.no_nul:
+ elif isinstance(s_item, SomeStringOrUnicode) and s_item.no_nul:
pass
else:
no_nul = False
break
- return SomeString(no_nul=no_nul)
+ return s_string.__class__(no_nul=no_nul)
-class __extend__(pairtype(SomeString, SomeObject)):
+class __extend__(pairtype(SomeString, SomeObject),
+ pairtype(SomeUnicodeString, SomeObject)):
- def mod((str, args)):
- getbookkeeper().count('strformat', str, args)
- return SomeString()
+ def mod((s_string, args)):
+ getbookkeeper().count('strformat', s_string, args)
+ return s_string.__class__()
class __extend__(pairtype(SomeFloat, SomeFloat)):
diff --git a/pypy/annotation/test/test_annrpython.py b/pypy/annotation/test/test_annrpython.py
--- a/pypy/annotation/test/test_annrpython.py
+++ b/pypy/annotation/test/test_annrpython.py
@@ -3389,6 +3389,22 @@
s = a.build_types(f, [str])
assert isinstance(s, annmodel.SomeString)
+ def test_unicodeformatting(self):
+ def f(x):
+ return u'%s' % x
+
+ a = self.RPythonAnnotator()
+ s = a.build_types(f, [unicode])
+ assert isinstance(s, annmodel.SomeUnicodeString)
+
+ def test_unicodeformatting_tuple(self):
+ def f(x):
+ return u'%s' % (x,)
+
+ a = self.RPythonAnnotator()
+ s = a.build_types(f, [unicode])
+ assert isinstance(s, annmodel.SomeUnicodeString)
+
def test_negative_slice(self):
def f(s, e):
diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py
--- a/pypy/config/pypyoption.py
+++ b/pypy/config/pypyoption.py
@@ -41,6 +41,7 @@
translation_modules.update(dict.fromkeys(
["fcntl", "rctime", "select", "signal", "_rawffi", "zlib",
"struct", "_md5", "cStringIO", "array", "_ffi",
+ "binascii",
# the following are needed for pyrepl (and hence for the
# interactive prompt/pdb)
"termios", "_minimal_curses",
diff --git a/pypy/doc/coding-guide.rst b/pypy/doc/coding-guide.rst
--- a/pypy/doc/coding-guide.rst
+++ b/pypy/doc/coding-guide.rst
@@ -255,7 +255,12 @@
code if the translator can prove that they are non-negative. When
slicing a string it is necessary to prove that the slice start and
stop indexes are non-negative. There is no implicit str-to-unicode cast
- anywhere.
+ anywhere. Simple string formatting using the ``%`` operator works, as long
+ as the format string is known at translation time; the only supported
+ formatting specifiers are ``%s``, ``%d``, ``%x``, ``%o``, ``%f``, plus
+ ``%r`` but only for user-defined instances. Modifiers such as conversion
+ flags, precision, length etc. are not supported. Moreover, it is forbidden
+ to mix unicode and strings when formatting.
**tuples**
diff --git a/pypy/doc/whatsnew-head.rst b/pypy/doc/whatsnew-head.rst
--- a/pypy/doc/whatsnew-head.rst
+++ b/pypy/doc/whatsnew-head.rst
@@ -14,5 +14,11 @@
.. branch: nupypy-axis-arg-check
Check that axis arg is valid in _numpypy
+.. branch: iterator-in-rpython
+.. branch: numpypy_count_nonzero
+.. branch: even-more-jit-hooks
+
+
.. "uninteresting" branches that we should just ignore for the whatsnew:
.. branch: slightly-shorter-c
+.. branch: better-enforceargs
diff --git a/pypy/jit/metainterp/compile.py b/pypy/jit/metainterp/compile.py
--- a/pypy/jit/metainterp/compile.py
+++ b/pypy/jit/metainterp/compile.py
@@ -225,6 +225,8 @@
assert isinstance(target_token, TargetToken)
assert loop_jitcell_token.target_tokens
loop_jitcell_token.target_tokens.append(target_token)
+ if target_token.short_preamble:
+ metainterp_sd.logger_ops.log_short_preamble([], target_token.short_preamble)
loop = partial_trace
loop.operations = loop.operations[:-1] + part.operations
diff --git a/pypy/jit/metainterp/history.py b/pypy/jit/metainterp/history.py
--- a/pypy/jit/metainterp/history.py
+++ b/pypy/jit/metainterp/history.py
@@ -706,6 +706,7 @@
self.virtual_state = None
self.exported_state = None
+ self.short_preamble = None
def repr_of_descr(self):
return 'TargetToken(%d)' % compute_unique_id(self)
diff --git a/pypy/jit/metainterp/optimizeopt/rewrite.py b/pypy/jit/metainterp/optimizeopt/rewrite.py
--- a/pypy/jit/metainterp/optimizeopt/rewrite.py
+++ b/pypy/jit/metainterp/optimizeopt/rewrite.py
@@ -241,6 +241,16 @@
# guard_nonnull_class on this value, which is rather silly.
# replace the original guard with a guard_value
old_guard_op = value.last_guard
+ if old_guard_op.getopnum() != rop.GUARD_NONNULL:
+ # This is only safe if the class of the guard_value matches the
+ # class of the guard_*_class, otherwise the intermediate ops might
+ # be executed with wrong classes.
+ previous_classbox = value.get_constant_class(self.optimizer.cpu)
+ expected_classbox = self.optimizer.cpu.ts.cls_of_box(op.getarg(1))
+ assert previous_classbox is not None
+ assert expected_classbox is not None
+ if not previous_classbox.same_constant(expected_classbox):
+ raise InvalidLoop('A GUARD_VALUE was proven to always fail')
op = old_guard_op.copy_and_change(rop.GUARD_VALUE,
args = [old_guard_op.getarg(0), op.getarg(1)])
self.optimizer.replaces_guard[op] = old_guard_op
@@ -251,6 +261,8 @@
assert isinstance(descr, compile.ResumeGuardDescr)
descr.guard_opnum = rop.GUARD_VALUE
descr.make_a_counter_per_value(op)
+ # to be safe
+ value.last_guard = None
constbox = op.getarg(1)
assert isinstance(constbox, Const)
self.optimize_guard(op, constbox)
diff --git a/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py b/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
--- a/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
+++ b/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
@@ -7862,6 +7862,17 @@
"""
self.optimize_loop(ops, expected)
+ def test_only_strengthen_guard_if_class_matches(self):
+ ops = """
+ [p1]
+ guard_class(p1, ConstClass(node_vtable2)) []
+ guard_value(p1, ConstPtr(myptr)) []
+ jump(p1)
+ """
+ self.raises(InvalidLoop, self.optimize_loop,
+ ops, ops)
+
+
class TestLLtype(OptimizeOptTest, LLtypeMixin):
pass
diff --git a/pypy/jit/metainterp/optimizeopt/unroll.py b/pypy/jit/metainterp/optimizeopt/unroll.py
--- a/pypy/jit/metainterp/optimizeopt/unroll.py
+++ b/pypy/jit/metainterp/optimizeopt/unroll.py
@@ -120,9 +120,9 @@
limit = self.optimizer.metainterp_sd.warmrunnerdesc.memory_manager.retrace_limit
if cell_token.retraced_count < limit:
cell_token.retraced_count += 1
- #debug_print('Retracing (%d/%d)' % (cell_token.retraced_count, limit))
+ debug_print('Retracing (%d/%d)' % (cell_token.retraced_count, limit))
else:
- #debug_print("Retrace count reached, jumping to preamble")
+ debug_print("Retrace count reached, jumping to preamble")
assert cell_token.target_tokens[0].virtual_state is None
jumpop.setdescr(cell_token.target_tokens[0])
self.optimizer.send_extra_operation(jumpop)
diff --git a/pypy/module/pypyjit/interp_resop.py b/pypy/module/pypyjit/interp_resop.py
--- a/pypy/module/pypyjit/interp_resop.py
+++ b/pypy/module/pypyjit/interp_resop.py
@@ -333,12 +333,12 @@
W_JitInfoSnapshot.typedef = TypeDef(
"JitInfoSnapshot",
- w_loop_run_times = interp_attrproperty_w("w_loop_run_times",
+ loop_run_times = interp_attrproperty_w("w_loop_run_times",
cls=W_JitInfoSnapshot),
- w_counters = interp_attrproperty_w("w_counters",
+ counters = interp_attrproperty_w("w_counters",
cls=W_JitInfoSnapshot,
doc="various JIT counters"),
- w_counter_times = interp_attrproperty_w("w_counter_times",
+ counter_times = interp_attrproperty_w("w_counter_times",
cls=W_JitInfoSnapshot,
doc="various JIT timers")
)
diff --git a/pypy/module/test_lib_pypy/test_distributed/__init__.py b/pypy/module/test_lib_pypy/test_distributed/__init__.py
deleted file mode 100644
diff --git a/pypy/module/test_lib_pypy/test_distributed/test_distributed.py b/pypy/module/test_lib_pypy/test_distributed/test_distributed.py
deleted file mode 100644
--- a/pypy/module/test_lib_pypy/test_distributed/test_distributed.py
+++ /dev/null
@@ -1,305 +0,0 @@
-import py; py.test.skip("xxx remove")
-
-""" Controllers tests
-"""
-
-from pypy.conftest import gettestobjspace
-import sys
-
-class AppTestDistributed(object):
- def setup_class(cls):
- cls.space = gettestobjspace(**{"objspace.std.withtproxy": True,
- "usemodules":("_continuation",)})
-
- def test_init(self):
- import distributed
-
- def test_protocol(self):
- from distributed.protocol import AbstractProtocol
- protocol = AbstractProtocol()
- for item in ("aaa", 3, u"aa", 344444444444444444L, 1.2, (1, "aa")):
- assert protocol.unwrap(protocol.wrap(item)) == item
- assert type(protocol.unwrap(protocol.wrap([1,2,3]))) is list
- assert type(protocol.unwrap(protocol.wrap({"a":3}))) is dict
-
- def f():
- pass
-
- assert type(protocol.unwrap(protocol.wrap(f))) is type(f)
-
- def test_method_of_false_obj(self):
- from distributed.protocol import AbstractProtocol
- protocol = AbstractProtocol()
- lst = []
- m = lst.append
- assert type(protocol.unwrap(protocol.wrap(m))) is type(m)
-
- def test_protocol_run(self):
- l = [1,2,3]
- from distributed.protocol import LocalProtocol
- protocol = LocalProtocol()
- wrap = protocol.wrap
- unwrap = protocol.unwrap
- item = unwrap(wrap(l))
- assert len(item) == 3
- assert item[2] == 3
- item += [1,1,1]
- assert len(item) == 6
-
- def test_protocol_call(self):
- def f(x, y):
- return x + y
-
- from distributed.protocol import LocalProtocol
- protocol = LocalProtocol()
- wrap = protocol.wrap
- unwrap = protocol.unwrap
- item = unwrap(wrap(f))
- assert item(3, 2) == 5
-
- def test_simulation_call(self):
- def f(x, y):
- return x + y
-
- import types
- from distributed import RemoteProtocol
- import sys
-
- data = []
- result = []
- protocol = RemoteProtocol(result.append, data.pop)
- data += [("finished", protocol.wrap(5)), ("finished", protocol.wrap(f))]
- fun = protocol.get_remote("f")
- assert isinstance(fun, types.FunctionType)
- assert fun(2, 3) == 5
-
- def test_local_obj(self):
- class A(object):
- def __init__(self, x):
- self.x = x
-
- def __len__(self):
- return self.x + 8
-
- from distributed.protocol import LocalProtocol
- protocol = LocalProtocol()
- wrap = protocol.wrap
- unwrap = protocol.unwrap
- item = unwrap(wrap(A(3)))
- assert item.x == 3
- assert len(item) == 11
-
-class AppTestDistributedTasklets(object):
- spaceconfig = {"objspace.std.withtproxy": True,
- "objspace.usemodules._continuation": True}
- reclimit = sys.getrecursionlimit()
-
- def setup_class(cls):
- import py.test
- py.test.importorskip('greenlet')
- cls.w_test_env_ = cls.space.appexec([], """():
- from distributed import test_env
- return (test_env,)
- """)
- sys.setrecursionlimit(100000)
-
- def teardown_class(cls):
- sys.setrecursionlimit(cls.reclimit)
-
- def test_remote_protocol_call(self):
- def f(x, y):
- return x + y
-
- protocol = self.test_env_[0]({"f": f})
- fun = protocol.get_remote("f")
- assert fun(2, 3) == 5
-
- def test_callback(self):
- def g():
- return 8
-
- def f(x):
- return x + g()
-
- protocol = self.test_env_[0]({"f":f})
- fun = protocol.get_remote("f")
- assert fun(8) == 16
-
- def test_remote_dict(self):
- #skip("Land of infinite recursion")
- d = {'a':3}
- protocol = self.test_env_[0]({'d':d})
- xd = protocol.get_remote('d')
- #assert d['a'] == xd['a']
- assert d.keys() == xd.keys()
- assert d.values() == xd.values()
- assert d == xd
-
- def test_remote_obj(self):
- class A(object):
- def __init__(self, x):
- self.x = x
-
- def __len__(self):
- return self.x + 8
- a = A(3)
-
- protocol = self.test_env_[0]({'a':a})
- xa = protocol.get_remote("a")
- assert xa.x == 3
- assert len(xa) == 11
-
- def test_remote_doc_and_callback(self):
- class A(object):
- """xxx"""
- def __init__(self):
- pass
-
- def meth(self, x):
- return x() + 3
-
- def x():
- return 1
-
- a = A()
-
- protocol = self.test_env_[0]({'a':a})
- xa = protocol.get_remote('a')
- assert xa.__class__.__doc__ == 'xxx'
- assert xa.meth(x) == 4
-
- def test_double_reference(self):
- class A(object):
- def meth(self, one):
- self.one = one
-
- def perform(self):
- return 1 + len(self.one())
-
- class B(object):
- def __call__(self):
- return [1,2,3]
-
- a = A()
- protocol = self.test_env_[0]({'a': a})
- xa = protocol.get_remote('a')
- xa.meth(B())
- assert xa.perform() == 4
-
- def test_frame(self):
- #skip("Land of infinite recursion")
- import sys
- f = sys._getframe()
- protocol = self.test_env_[0]({'f':f})
- xf = protocol.get_remote('f')
- assert f.f_globals.keys() == xf.f_globals.keys()
- assert f.f_locals.keys() == xf.f_locals.keys()
-
- def test_remote_exception(self):
- def raising():
- 1/0
-
- protocol = self.test_env_[0]({'raising':raising})
- xr = protocol.get_remote('raising')
- try:
- xr()
- except ZeroDivisionError:
- import sys
- exc_info, val, tb = sys.exc_info()
- #assert tb.tb_next is None
- else:
- raise AssertionError("Did not raise")
-
- def test_remote_classmethod(self):
- class A(object):
- z = 8
-
- @classmethod
- def x(cls):
- return cls.z
-
- a = A()
- protocol = self.test_env_[0]({'a':a})
- xa = protocol.get_remote("a")
- res = xa.x()
- assert res == 8
-
- def test_types_reverse_mapping(self):
- class A(object):
- def m(self, tp):
- assert type(self) is tp
-
- a = A()
- protocol = self.test_env_[0]({'a':a, 'A':A})
- xa = protocol.get_remote('a')
- xA = protocol.get_remote('A')
- xa.m(xA)
-
- def test_instantiate_remote_type(self):
- class C(object):
- def __init__(self, y):
- self.y = y
-
- def x(self):
- return self.y
-
- protocol = self.test_env_[0]({'C':C})
- xC = protocol.get_remote('C')
- xc = xC(3)
- res = xc.x()
- assert res == 3
-
- def test_remote_sys(self):
- skip("Fix me some day maybe")
- import sys
-
- protocol = self.test_env_[0]({'sys':sys})
- s = protocol.get_remote('sys')
- l = dir(s)
- assert l
-
- def test_remote_file_access(self):
- skip("Descriptor logic seems broken")
- protocol = self.test_env_[0]({'f':open})
- xf = protocol.get_remote('f')
- data = xf('/etc/passwd').read()
- assert data
-
- def test_real_descriptor(self):
- class getdesc(object):
- def __get__(self, obj, val=None):
- if obj is not None:
- assert type(obj) is X
- return 3
-
- class X(object):
- x = getdesc()
-
- x = X()
-
- protocol = self.test_env_[0]({'x':x})
- xx = protocol.get_remote('x')
- assert xx.x == 3
-
- def test_bases(self):
- class X(object):
- pass
-
- class Y(X):
- pass
-
- y = Y()
- protocol = self.test_env_[0]({'y':y, 'X':X})
- xy = protocol.get_remote('y')
- xX = protocol.get_remote('X')
- assert isinstance(xy, xX)
-
- def test_key_error(self):
- from distributed import ObjectNotFound
- protocol = self.test_env_[0]({})
- raises(ObjectNotFound, "protocol.get_remote('x')")
-
- def test_list_items(self):
- protocol = self.test_env_[0]({'x':3, 'y':8})
- assert sorted(protocol.remote_keys()) == ['x', 'y']
-
diff --git a/pypy/module/test_lib_pypy/test_distributed/test_greensock.py b/pypy/module/test_lib_pypy/test_distributed/test_greensock.py
deleted file mode 100644
--- a/pypy/module/test_lib_pypy/test_distributed/test_greensock.py
+++ /dev/null
@@ -1,61 +0,0 @@
-import py; py.test.skip("xxx remove")
-from pypy.conftest import gettestobjspace, option
-
-def setup_module(mod):
- py.test.importorskip("pygreen") # found e.g. in py/trunk/contrib
-
-class AppTestDistributedGreensock(object):
- def setup_class(cls):
- if not option.runappdirect:
- py.test.skip("Cannot run this on top of py.py because of PopenGateway")
- cls.space = gettestobjspace(**{"objspace.std.withtproxy": True,
- "usemodules":("_continuation",)})
- cls.w_remote_side_code = cls.space.appexec([], """():
- import sys
- sys.path.insert(0, '%s')
- remote_side_code = '''
-class A:
- def __init__(self, x):
- self.x = x
-
- def __len__(self):
- return self.x + 8
-
- def raising(self):
- 1/0
-
- def method(self, x):
- return x() + self.x
-
-a = A(3)
-
-def count():
- x = 10
- # naive counting :)
- result = 1
- for i in range(x):
- result += 1
- return result
-'''
- return remote_side_code
- """ % str(py.path.local(__file__).dirpath().dirpath().dirpath().dirpath()))
-
- def test_remote_call(self):
- from distributed import socklayer
- import sys
- from pygreen.greenexecnet import PopenGateway
- gw = PopenGateway()
- rp = socklayer.spawn_remote_side(self.remote_side_code, gw)
- a = rp.get_remote("a")
- assert a.method(lambda : 13) == 16
-
- def test_remote_counting(self):
- from distributed import socklayer
- from pygreen.greensock2 import allof
- from pygreen.greenexecnet import PopenGateway
- gws = [PopenGateway() for i in range(3)]
- rps = [socklayer.spawn_remote_side(self.remote_side_code, gw)
- for gw in gws]
- counters = [rp.get_remote("count") for rp in rps]
- assert allof(*counters) == (11, 11, 11)
-
diff --git a/pypy/module/test_lib_pypy/test_distributed/test_socklayer.py b/pypy/module/test_lib_pypy/test_distributed/test_socklayer.py
deleted file mode 100644
--- a/pypy/module/test_lib_pypy/test_distributed/test_socklayer.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import py; py.test.skip("xxx remove")
-from pypy.conftest import gettestobjspace
-
-def setup_module(mod):
- py.test.importorskip("pygreen") # found e.g. in py/trunk/contrib
-
-# XXX think how to close the socket
-
-class AppTestSocklayer:
- def setup_class(cls):
- cls.space = gettestobjspace(**{"objspace.std.withtproxy": True,
- "usemodules":("_continuation",
- "_socket", "select")})
-
- def test_socklayer(self):
- class X(object):
- z = 3
-
- x = X()
-
- try:
- import py
- except ImportError:
- skip("pylib not importable")
- from pygreen.pipe.gsocke import GreenSocket
- from distributed.socklayer import socket_loop, connect
- from pygreen.greensock2 import oneof, allof
-
- def one():
- socket_loop(('127.0.0.1', 21211), {'x':x}, socket=GreenSocket)
-
- def two():
- rp = connect(('127.0.0.1', 21211), GreenSocket)
- assert rp.x.z == 3
-
- oneof(one, two)
diff --git a/pypy/objspace/std/strutil.py b/pypy/objspace/std/strutil.py
--- a/pypy/objspace/std/strutil.py
+++ b/pypy/objspace/std/strutil.py
@@ -185,4 +185,4 @@
try:
return rstring_to_float(s)
except ValueError:
- raise ParseStringError("invalid literal for float()")
+ raise ParseStringError("invalid literal for float(): '%s'" % s)
diff --git a/pypy/objspace/std/test/test_floatobject.py b/pypy/objspace/std/test/test_floatobject.py
--- a/pypy/objspace/std/test/test_floatobject.py
+++ b/pypy/objspace/std/test/test_floatobject.py
@@ -441,6 +441,13 @@
b = A(5).real
assert type(b) is float
+ def test_invalid_literal_message(self):
+ try:
+ float('abcdef')
+ except ValueError, e:
+ assert 'abcdef' in e.message
+ else:
+ assert False, 'did not raise'
class AppTestFloatHex:
def w_identical(self, x, y):
diff --git a/pypy/objspace/std/test/test_methodcache.py b/pypy/objspace/std/test/test_methodcache.py
--- a/pypy/objspace/std/test/test_methodcache.py
+++ b/pypy/objspace/std/test/test_methodcache.py
@@ -1,8 +1,8 @@
from pypy.conftest import gettestobjspace
-from pypy.objspace.std.test.test_typeobject import AppTestTypeObject
+from pypy.objspace.std.test import test_typeobject
-class AppTestMethodCaching(AppTestTypeObject):
+class AppTestMethodCaching(test_typeobject.AppTestTypeObject):
def setup_class(cls):
cls.space = gettestobjspace(
**{"objspace.std.withmethodcachecounter": True})
diff --git a/pypy/rlib/objectmodel.py b/pypy/rlib/objectmodel.py
--- a/pypy/rlib/objectmodel.py
+++ b/pypy/rlib/objectmodel.py
@@ -3,9 +3,11 @@
RPython-compliant way.
"""
+import py
import sys
import types
import math
+import inspect
# specialize is a decorator factory for attaching _annspecialcase_
# attributes to functions: for example
@@ -106,15 +108,68 @@
specialize = _Specialize()
-def enforceargs(*args):
+def enforceargs(*types, **kwds):
""" Decorate a function with forcing of RPython-level types on arguments.
None means no enforcing.
- XXX shouldn't we also add asserts in function body?
+ When not translated, the type of the actual arguments are checked against
+ the enforced types every time the function is called. You can disable the
+ typechecking by passing ``typecheck=False`` to @enforceargs.
"""
+ typecheck = kwds.pop('typecheck', True)
+ if kwds:
+ raise TypeError, 'got an unexpected keyword argument: %s' % kwds.keys()
+ if not typecheck:
+ def decorator(f):
+ f._annenforceargs_ = types
+ return f
+ return decorator
+ #
+ from pypy.annotation.signature import annotationoftype
+ from pypy.annotation.model import SomeObject
def decorator(f):
- f._annenforceargs_ = args
- return f
+ def get_annotation(t):
+ if isinstance(t, SomeObject):
+ return t
+ return annotationoftype(t)
+ def typecheck(*args):
+ for i, (expected_type, arg) in enumerate(zip(types, args)):
+ if expected_type is None:
+ continue
+ s_expected = get_annotation(expected_type)
+ s_argtype = get_annotation(type(arg))
+ if not s_expected.contains(s_argtype):
+ msg = "%s argument number %d must be of type %s" % (
+ f.func_name, i+1, expected_type)
+ raise TypeError, msg
+ #
+ # we cannot simply wrap the function using *args, **kwds, because it's
+ # not RPython. Instead, we generate a function with exactly the same
+ # argument list
+ argspec = inspect.getargspec(f)
+ assert len(argspec.args) == len(types), (
+ 'not enough types provided: expected %d, got %d' %
+ (len(types), len(argspec.args)))
+ assert not argspec.varargs, '*args not supported by enforceargs'
+ assert not argspec.keywords, '**kwargs not supported by enforceargs'
+ #
+ arglist = ', '.join(argspec.args)
+ src = py.code.Source("""
+ def {name}({arglist}):
+ if not we_are_translated():
+ typecheck({arglist})
+ return {name}_original({arglist})
+ """.format(name=f.func_name, arglist=arglist))
+ #
+ mydict = {f.func_name + '_original': f,
+ 'typecheck': typecheck,
+ 'we_are_translated': we_are_translated}
+ exec src.compile() in mydict
+ result = mydict[f.func_name]
+ result.func_defaults = f.func_defaults
+ result.func_dict.update(f.func_dict)
+ result._annenforceargs_ = types
+ return result
return decorator
# ____________________________________________________________
diff --git a/pypy/rlib/rgc.py b/pypy/rlib/rgc.py
--- a/pypy/rlib/rgc.py
+++ b/pypy/rlib/rgc.py
@@ -138,8 +138,8 @@
return hop.genop(opname, vlist, resulttype = hop.r_result.lowleveltype)
@jit.oopspec('list.ll_arraycopy(source, dest, source_start, dest_start, length)')
+ at enforceargs(None, None, int, int, int)
@specialize.ll()
- at enforceargs(None, None, int, int, int)
def ll_arraycopy(source, dest, source_start, dest_start, length):
from pypy.rpython.lltypesystem.lloperation import llop
from pypy.rlib.objectmodel import keepalive_until_here
diff --git a/pypy/rlib/rsre/rpy.py b/pypy/rlib/rsre/rpy.py
--- a/pypy/rlib/rsre/rpy.py
+++ b/pypy/rlib/rsre/rpy.py
@@ -1,6 +1,7 @@
from pypy.rlib.rsre import rsre_char
from pypy.rlib.rsre.rsre_core import match
+from pypy.rlib.rarithmetic import intmask
def get_hacked_sre_compile(my_compile):
"""Return a copy of the sre_compile module for which the _sre
@@ -33,7 +34,7 @@
class GotIt(Exception):
pass
def my_compile(pattern, flags, code, *args):
- raise GotIt(code, flags, args)
+ raise GotIt([intmask(i) for i in code], flags, args)
sre_compile_hacked = get_hacked_sre_compile(my_compile)
def get_code(regexp, flags=0, allargs=False):
diff --git a/pypy/rlib/test/test_objectmodel.py b/pypy/rlib/test/test_objectmodel.py
--- a/pypy/rlib/test/test_objectmodel.py
+++ b/pypy/rlib/test/test_objectmodel.py
@@ -420,9 +420,45 @@
def test_enforceargs_decorator():
@enforceargs(int, str, None)
def f(a, b, c):
- pass
+ return a, b, c
+ f.foo = 'foo'
+ assert f._annenforceargs_ == (int, str, None)
+ assert f.func_name == 'f'
+ assert f.foo == 'foo'
+ assert f(1, 'hello', 42) == (1, 'hello', 42)
+ exc = py.test.raises(TypeError, "f(1, 2, 3)")
+ assert exc.value.message == "f argument number 2 must be of type <type 'str'>"
+ py.test.raises(TypeError, "f('hello', 'world', 3)")
+
+def test_enforceargs_defaults():
+ @enforceargs(int, int)
+ def f(a, b=40):
+ return a+b
+ assert f(2) == 42
+
+def test_enforceargs_int_float_promotion():
+ @enforceargs(float)
+ def f(x):
+ return x
+ # in RPython there is an implicit int->float promotion
+ assert f(42) == 42
+
+def test_enforceargs_no_typecheck():
+ @enforceargs(int, str, None, typecheck=False)
+ def f(a, b, c):
+ return a, b, c
assert f._annenforceargs_ == (int, str, None)
+ assert f(1, 2, 3) == (1, 2, 3) # no typecheck
+
+def test_enforceargs_translates():
+ from pypy.rpython.lltypesystem import lltype
+ @enforceargs(int, float)
+ def f(a, b):
+ return a, b
+ graph = getgraph(f, [int, int])
+ TYPES = [v.concretetype for v in graph.getargs()]
+ assert TYPES == [lltype.Signed, lltype.Float]
def getgraph(f, argtypes):
from pypy.translator.translator import TranslationContext, graphof
diff --git a/pypy/rpython/lltypesystem/rstr.py b/pypy/rpython/lltypesystem/rstr.py
--- a/pypy/rpython/lltypesystem/rstr.py
+++ b/pypy/rpython/lltypesystem/rstr.py
@@ -1,5 +1,6 @@
from weakref import WeakValueDictionary
from pypy.tool.pairtype import pairtype
+from pypy.annotation import model as annmodel
from pypy.rpython.error import TyperError
from pypy.rlib.objectmodel import malloc_zero_filled, we_are_translated
from pypy.rlib.objectmodel import _hash_string, enforceargs
@@ -169,6 +170,13 @@
return result
@jit.elidable
+ def ll_unicode(self, s):
+ if s:
+ return s
+ else:
+ return self.convert_const(u'None')
+
+ @jit.elidable
def ll_encode_latin1(self, s):
length = len(s.chars)
result = mallocstr(length)
@@ -962,13 +970,18 @@
def do_stringformat(cls, hop, sourcevarsrepr):
s_str = hop.args_s[0]
assert s_str.is_constant()
+ is_unicode = isinstance(s_str, annmodel.SomeUnicodeString)
+ if is_unicode:
+ TEMPBUF = TEMP_UNICODE
+ else:
+ TEMPBUF = TEMP
s = s_str.const
things = cls.parse_fmt_string(s)
size = inputconst(Signed, len(things)) # could be unsigned?
- cTEMP = inputconst(Void, TEMP)
+ cTEMP = inputconst(Void, TEMPBUF)
cflags = inputconst(Void, {'flavor': 'gc'})
vtemp = hop.genop("malloc_varsize", [cTEMP, cflags, size],
- resulttype=Ptr(TEMP))
+ resulttype=Ptr(TEMPBUF))
argsiter = iter(sourcevarsrepr)
@@ -979,7 +992,13 @@
vitem, r_arg = argsiter.next()
if not hasattr(r_arg, 'll_str'):
raise TyperError("ll_str unsupported for: %r" % r_arg)
- if code == 's' or (code == 'r' and isinstance(r_arg, InstanceRepr)):
+ if code == 's':
+ if is_unicode:
+ # only UniCharRepr and UnicodeRepr has it so far
+ vchunk = hop.gendirectcall(r_arg.ll_unicode, vitem)
+ else:
+ vchunk = hop.gendirectcall(r_arg.ll_str, vitem)
+ elif code == 'r' and isinstance(r_arg, InstanceRepr):
vchunk = hop.gendirectcall(r_arg.ll_str, vitem)
elif code == 'd':
assert isinstance(r_arg, IntegerRepr)
@@ -999,9 +1018,17 @@
else:
raise TyperError, "%%%s is not RPython" % (code, )
else:
- from pypy.rpython.lltypesystem.rstr import string_repr
- vchunk = inputconst(string_repr, thing)
+ from pypy.rpython.lltypesystem.rstr import string_repr, unicode_repr
+ if is_unicode:
+ vchunk = inputconst(unicode_repr, thing)
+ else:
+ vchunk = inputconst(string_repr, thing)
i = inputconst(Signed, i)
+ if is_unicode and vchunk.concretetype != Ptr(UNICODE):
+ # if we are here, one of the ll_str.* functions returned some
+ # STR, so we convert it to unicode. It's a bit suboptimal
+ # because we do one extra copy.
+ vchunk = hop.gendirectcall(cls.ll_str2unicode, vchunk)
hop.genop('setarrayitem', [vtemp, i, vchunk])
hop.exception_cannot_occur() # to ignore the ZeroDivisionError of '%'
@@ -1009,6 +1036,7 @@
do_stringformat = classmethod(do_stringformat)
TEMP = GcArray(Ptr(STR))
+TEMP_UNICODE = GcArray(Ptr(UNICODE))
# ____________________________________________________________
diff --git a/pypy/rpython/ootypesystem/rstr.py b/pypy/rpython/ootypesystem/rstr.py
--- a/pypy/rpython/ootypesystem/rstr.py
+++ b/pypy/rpython/ootypesystem/rstr.py
@@ -1,4 +1,5 @@
from pypy.tool.pairtype import pairtype
+from pypy.annotation import model as annmodel
from pypy.rlib.rarithmetic import ovfcheck
from pypy.rpython.error import TyperError
from pypy.rpython.rstr import AbstractStringRepr,AbstractCharRepr,\
@@ -79,6 +80,12 @@
sb.ll_append_char(cast_primitive(Char, c))
return sb.ll_build()
+ def ll_unicode(self, s):
+ if s:
+ return s
+ else:
+ return self.convert_const(u'None')
+
def ll_encode_latin1(self, value):
sb = ootype.new(ootype.StringBuilder)
length = value.ll_strlen()
@@ -312,6 +319,7 @@
string_repr = hop.rtyper.type_system.rstr.string_repr
s_str = hop.args_s[0]
assert s_str.is_constant()
+ is_unicode = isinstance(s_str, annmodel.SomeUnicodeString)
s = s_str.const
c_append = hop.inputconst(ootype.Void, 'll_append')
@@ -320,8 +328,15 @@
c8 = hop.inputconst(ootype.Signed, 8)
c10 = hop.inputconst(ootype.Signed, 10)
c16 = hop.inputconst(ootype.Signed, 16)
- c_StringBuilder = hop.inputconst(ootype.Void, ootype.StringBuilder)
- v_buf = hop.genop("new", [c_StringBuilder], resulttype=ootype.StringBuilder)
+ if is_unicode:
+ StringBuilder = ootype.UnicodeBuilder
+ RESULT = ootype.Unicode
+ else:
+ StringBuilder = ootype.StringBuilder
+ RESULT = ootype.String
+
+ c_StringBuilder = hop.inputconst(ootype.Void, StringBuilder)
+ v_buf = hop.genop("new", [c_StringBuilder], resulttype=StringBuilder)
things = cls.parse_fmt_string(s)
argsiter = iter(sourcevarsrepr)
@@ -331,7 +346,12 @@
vitem, r_arg = argsiter.next()
if not hasattr(r_arg, 'll_str'):
raise TyperError("ll_str unsupported for: %r" % r_arg)
- if code == 's' or (code == 'r' and isinstance(r_arg, InstanceRepr)):
+ if code == 's':
+ if is_unicode:
+ vchunk = hop.gendirectcall(r_arg.ll_unicode, vitem)
+ else:
+ vchunk = hop.gendirectcall(r_arg.ll_str, vitem)
+ elif code == 'r' and isinstance(r_arg, InstanceRepr):
vchunk = hop.gendirectcall(r_arg.ll_str, vitem)
elif code == 'd':
assert isinstance(r_arg, IntegerRepr)
@@ -348,13 +368,19 @@
else:
raise TyperError, "%%%s is not RPython" % (code, )
else:
- vchunk = hop.inputconst(string_repr, thing)
- #i = inputconst(Signed, i)
- #hop.genop('setarrayitem', [vtemp, i, vchunk])
+ if is_unicode:
+ vchunk = hop.inputconst(unicode_repr, thing)
+ else:
+ vchunk = hop.inputconst(string_repr, thing)
+ if is_unicode and vchunk.concretetype != ootype.Unicode:
+ # if we are here, one of the ll_str.* functions returned some
+ # STR, so we convert it to unicode. It's a bit suboptimal
+ # because we do one extra copy.
+ vchunk = hop.gendirectcall(cls.ll_str2unicode, vchunk)
hop.genop('oosend', [c_append, v_buf, vchunk], resulttype=ootype.Void)
hop.exception_cannot_occur() # to ignore the ZeroDivisionError of '%'
- return hop.genop('oosend', [c_build, v_buf], resulttype=ootype.String)
+ return hop.genop('oosend', [c_build, v_buf], resulttype=RESULT)
do_stringformat = classmethod(do_stringformat)
diff --git a/pypy/rpython/rpbc.py b/pypy/rpython/rpbc.py
--- a/pypy/rpython/rpbc.py
+++ b/pypy/rpython/rpbc.py
@@ -11,7 +11,7 @@
mangle, inputdesc, warning, impossible_repr
from pypy.rpython import rclass
from pypy.rpython import robject
-from pypy.rpython.annlowlevel import llstr
+from pypy.rpython.annlowlevel import llstr, llunicode
from pypy.rpython import callparse
diff --git a/pypy/rpython/rstr.py b/pypy/rpython/rstr.py
--- a/pypy/rpython/rstr.py
+++ b/pypy/rpython/rstr.py
@@ -483,6 +483,8 @@
# xxx suboptimal, maybe
return str(unicode(ch))
+ def ll_unicode(self, ch):
+ return unicode(ch)
class __extend__(AbstractCharRepr,
AbstractUniCharRepr):
diff --git a/pypy/rpython/test/test_runicode.py b/pypy/rpython/test/test_runicode.py
--- a/pypy/rpython/test/test_runicode.py
+++ b/pypy/rpython/test/test_runicode.py
@@ -1,3 +1,4 @@
+# -*- encoding: utf-8 -*-
from pypy.rpython.lltypesystem.lltype import malloc
from pypy.rpython.lltypesystem.rstr import LLHelpers, UNICODE
@@ -194,7 +195,16 @@
assert self.interpret(fn, [u'(']) == False
assert self.interpret(fn, [u'\u1058']) == False
assert self.interpret(fn, [u'X']) == True
-
+
+ def test_strformat_unicode_arg(self):
+ const = self.const
+ def percentS(s):
+ return const("before %s after") % (s,)
+ #
+ res = self.interpret(percentS, [const(u'à')])
+ assert self.ll_to_string(res) == const(u'before à after')
+ #
+
def unsupported(self):
py.test.skip("not supported")
@@ -202,12 +212,6 @@
test_upper = unsupported
test_lower = unsupported
test_splitlines = unsupported
- test_strformat = unsupported
- test_strformat_instance = unsupported
- test_strformat_nontuple = unsupported
- test_percentformat_instance = unsupported
- test_percentformat_tuple = unsupported
- test_percentformat_list = unsupported
test_int = unsupported
test_int_valueerror = unsupported
test_float = unsupported
More information about the pypy-commit
mailing list