[pypy-svn] pypy interplevel-exception-classes: Merge default
amauryfa
commits-noreply at bitbucket.org
Fri Feb 18 11:49:07 CET 2011
Author: Amaury Forgeot d'Arc <amauryfa at gmail.com>
Branch: interplevel-exception-classes
Changeset: r42138:631267330434
Date: 2011-02-18 10:40 +0100
http://bitbucket.org/pypy/pypy/changeset/631267330434/
Log: Merge default
diff --git a/pypy/module/_socket/interp_socket.py b/pypy/module/_socket/interp_socket.py
--- a/pypy/module/_socket/interp_socket.py
+++ b/pypy/module/_socket/interp_socket.py
@@ -1,8 +1,7 @@
from pypy.interpreter.baseobjspace import Wrappable
from pypy.interpreter.typedef import TypeDef, make_weakref_descr,\
interp_attrproperty
-from pypy.interpreter.gateway import ObjSpace, W_Root, NoneNotWrapped
-from pypy.interpreter.gateway import interp2app
+from pypy.interpreter.gateway import NoneNotWrapped, interp2app, unwrap_spec
from pypy.rlib.rarithmetic import intmask
from pypy.rlib import rsocket
from pypy.rlib.rsocket import RSocket, AF_INET, SOCK_STREAM
@@ -36,7 +35,6 @@
addr.as_object(sock.fd, space)])
except SocketError, e:
raise converted_error(space, e)
- accept_w.unwrap_spec = ['self', ObjSpace]
def bind_w(self, space, w_addr):
"""bind(address)
@@ -49,7 +47,6 @@
self.bind(self.addr_from_object(space, w_addr))
except SocketError, e:
raise converted_error(space, e)
- bind_w.unwrap_spec = ['self', ObjSpace, W_Root]
def close_w(self, space):
"""close()
@@ -60,7 +57,6 @@
self.close()
except SocketError, e:
raise converted_error(space, e)
- close_w.unwrap_spec = ['self', ObjSpace]
def connect_w(self, space, w_addr):
"""connect(address)
@@ -75,7 +71,6 @@
except TypeError, e:
raise OperationError(space.w_TypeError,
space.wrap(str(e)))
- connect_w.unwrap_spec = ['self', ObjSpace, W_Root]
def connect_ex_w(self, space, w_addr):
"""connect_ex(address) -> errno
@@ -89,14 +84,12 @@
raise converted_error(space, e)
error = self.connect_ex(addr)
return space.wrap(error)
- connect_ex_w.unwrap_spec = ['self', ObjSpace, W_Root]
def dup_w(self, space):
try:
return self.dup(W_RSocket)
except SocketError, e:
raise converted_error(space, e)
- dup_w.unwrap_spec = ['self', ObjSpace]
def fileno_w(self, space):
"""fileno() -> integer
@@ -104,7 +97,6 @@
Return the integer file descriptor of the socket.
"""
return space.wrap(intmask(self.fd))
- fileno_w.unwrap_spec = ['self', ObjSpace]
def getpeername_w(self, space):
"""getpeername() -> address info
@@ -117,7 +109,6 @@
return addr.as_object(self.fd, space)
except SocketError, e:
raise converted_error(space, e)
- getpeername_w.unwrap_spec = ['self', ObjSpace]
def getsockname_w(self, space):
"""getsockname() -> address info
@@ -130,8 +121,8 @@
return addr.as_object(self.fd, space)
except SocketError, e:
raise converted_error(space, e)
- getsockname_w.unwrap_spec = ['self', ObjSpace]
+ @unwrap_spec(level=int, optname=int)
def getsockopt_w(self, space, level, optname, w_buflen=NoneNotWrapped):
"""getsockopt(level, option[, buffersize]) -> value
@@ -146,7 +137,6 @@
raise converted_error(space, e)
buflen = space.int_w(w_buflen)
return space.wrap(self.getsockopt(level, optname, buflen))
- getsockopt_w.unwrap_spec = ['self', ObjSpace, int, int, W_Root]
def gettimeout_w(self, space):
"""gettimeout() -> timeout
@@ -158,8 +148,8 @@
if timeout < 0.0:
return space.w_None
return space.wrap(timeout)
- gettimeout_w.unwrap_spec = ['self', ObjSpace]
-
+
+ @unwrap_spec(backlog=int)
def listen_w(self, space, backlog):
"""listen(backlog)
@@ -171,7 +161,6 @@
self.listen(backlog)
except SocketError, e:
raise converted_error(space, e)
- listen_w.unwrap_spec = ['self', ObjSpace, int]
def makefile_w(self, space, w_mode="r", w_buffsize=-1):
"""makefile([mode[, buffersize]]) -> file object
@@ -180,10 +169,8 @@
The mode and buffersize arguments are as for the built-in open() function.
"""
return app_makefile(space, self, w_mode, w_buffsize)
- makefile_w.unwrap_spec = ['self', ObjSpace, W_Root, W_Root]
-
-
-
+
+ @unwrap_spec(buffersize='nonnegint', flags=int)
def recv_w(self, space, buffersize, flags=0):
"""recv(buffersize[, flags]) -> data
@@ -197,8 +184,8 @@
except SocketError, e:
raise converted_error(space, e)
return space.wrap(data)
- recv_w.unwrap_spec = ['self', ObjSpace, 'nonnegint', int]
+ @unwrap_spec(buffersize='nonnegint', flags=int)
def recvfrom_w(self, space, buffersize, flags=0):
"""recvfrom(buffersize[, flags]) -> (data, address info)
@@ -213,8 +200,8 @@
return space.newtuple([space.wrap(data), w_addr])
except SocketError, e:
raise converted_error(space, e)
- recvfrom_w.unwrap_spec = ['self', ObjSpace, 'nonnegint', int]
+ @unwrap_spec(data='bufferstr', flags=int)
def send_w(self, space, data, flags=0):
"""send(data[, flags]) -> count
@@ -227,8 +214,8 @@
except SocketError, e:
raise converted_error(space, e)
return space.wrap(count)
- send_w.unwrap_spec = ['self', ObjSpace, 'bufferstr', int]
+ @unwrap_spec(data='bufferstr', flags=int)
def sendall_w(self, space, data, flags=0):
"""sendall(data[, flags])
@@ -241,8 +228,8 @@
count = self.sendall(data, flags, SignalChecker(space))
except SocketError, e:
raise converted_error(space, e)
- sendall_w.unwrap_spec = ['self', ObjSpace, 'bufferstr', int]
+ @unwrap_spec(data='bufferstr')
def sendto_w(self, space, data, w_param2, w_param3=NoneNotWrapped):
"""sendto(data[, flags], address) -> count
@@ -263,18 +250,18 @@
except SocketError, e:
raise converted_error(space, e)
return space.wrap(count)
- sendto_w.unwrap_spec = ['self', ObjSpace, 'bufferstr', W_Root, W_Root]
- def setblocking_w(self, space, flag):
+ @unwrap_spec(flag=bool)
+ def setblocking_w(self, flag):
"""setblocking(flag)
Set the socket to blocking (flag is true) or non-blocking (false).
setblocking(True) is equivalent to settimeout(None);
setblocking(False) is equivalent to settimeout(0.0).
"""
- self.setblocking(bool(flag))
- setblocking_w.unwrap_spec = ['self', ObjSpace, int]
+ self.setblocking(flag)
+ @unwrap_spec(level=int, optname=int)
def setsockopt_w(self, space, level, optname, w_optval):
"""setsockopt(level, option, value)
@@ -294,9 +281,7 @@
self.setsockopt_int(level, optname, optval)
except SocketError, e:
raise converted_error(space, e)
-
- setsockopt_w.unwrap_spec = ['self', ObjSpace, int, int, W_Root]
-
+
def settimeout_w(self, space, w_timeout):
"""settimeout(timeout)
@@ -313,8 +298,8 @@
raise OperationError(space.w_ValueError,
space.wrap('Timeout value out of range'))
self.settimeout(timeout)
- settimeout_w.unwrap_spec = ['self', ObjSpace, W_Root]
+ @unwrap_spec(nbytes=int, flags=int)
def recv_into_w(self, space, w_buffer, nbytes=0, flags=0):
rwbuffer = space.rwbuffer_w(w_buffer)
lgt = rwbuffer.getlength()
@@ -325,8 +310,7 @@
except SocketError, e:
raise converted_error(space, e)
- recv_into_w.unwrap_spec = ['self', ObjSpace, W_Root, int, int]
-
+ @unwrap_spec(nbytes=int, flags=int)
def recvfrom_into_w(self, space, w_buffer, nbytes=0, flags=0):
rwbuffer = space.rwbuffer_w(w_buffer)
lgt = rwbuffer.getlength()
@@ -341,8 +325,8 @@
return space.newtuple([space.wrap(readlgt), w_addr])
except SocketError, e:
raise converted_error(space, e)
- recvfrom_into_w.unwrap_spec = ['self', ObjSpace, W_Root, int, int]
+ @unwrap_spec(cmd=int)
def ioctl_w(self, space, cmd, w_option):
from pypy.rpython.lltypesystem import rffi, lltype
from pypy.rlib import rwin32
@@ -382,8 +366,8 @@
return space.wrap(recv_ptr[0])
finally:
lltype.free(recv_ptr, flavor='raw')
- ioctl_w.unwrap_spec = ['self', ObjSpace, int, W_Root]
+ @unwrap_spec(how=int)
def shutdown_w(self, space, how):
"""shutdown(flag)
@@ -395,7 +379,6 @@
self.shutdown(how)
except SocketError, e:
raise converted_error(space, e)
- shutdown_w.unwrap_spec = ['self', ObjSpace, int]
#------------------------------------------------------------
# Support functions for socket._socketobject
@@ -407,7 +390,6 @@
Intended only to be used by socket._socketobject
"""
self.usecount += 1
- _reuse_w.unwrap_spec = ['self']
def _drop_w(self, space):
"""_drop()
@@ -420,7 +402,6 @@
if self.usecount > 0:
return
self.close_w(space)
- _drop_w.unwrap_spec = ['self', ObjSpace]
app_makefile = gateway.applevel(r'''
def makefile(self, mode="r", buffersize=-1):
@@ -434,6 +415,7 @@
return os.fdopen(newfd, mode, buffersize)
''', filename =__file__).interphook('makefile')
+ at unwrap_spec(family=int, type=int, proto=int)
def newsocket(space, w_subtype, family=AF_INET,
type=SOCK_STREAM, proto=0):
# XXX If we want to support subclassing the socket type we will need
@@ -446,8 +428,7 @@
except SocketError, e:
raise converted_error(space, e)
return space.wrap(sock)
-descr_socket_new = interp2app(newsocket,
- unwrap_spec=[ObjSpace, W_Root, int, int, int])
+descr_socket_new = interp2app(newsocket)
# ____________________________________________________________
# Error handling
@@ -503,9 +484,7 @@
socketmethods = {}
for methodname in socketmethodnames:
method = getattr(W_RSocket, methodname + '_w')
- assert hasattr(method,'unwrap_spec'), methodname
- assert method.im_func.func_code.co_argcount == len(method.unwrap_spec), methodname
- socketmethods[methodname] = interp2app(method, unwrap_spec=method.unwrap_spec)
+ socketmethods[methodname] = interp2app(method)
W_RSocket.typedef = TypeDef("_socket.socket",
__doc__ = """\
diff --git a/pypy/module/math/_genmath.py b/pypy/module/math/_genmath.py
deleted file mode 100644
--- a/pypy/module/math/_genmath.py
+++ /dev/null
@@ -1,62 +0,0 @@
-# ONESHOT SCRIPT (probably can go away soon)
-# to generate the mixed module 'math' (see same directory)
-import py
-import math
-import re
-import sys
-rex_arg = re.compile(".*\((.*)\).*")
-
-if __name__ == '__main__':
- print py.code.Source("""
- import math
- from pypy.interpreter.gateway import ObjSpace
-
- """)
- names = []
- for name, func in math.__dict__.items():
- if not callable(func):
- continue
- sig = func.__doc__.split('\n')[0].strip()
- sig = sig.split('->')[0].strip()
- m = rex_arg.match(sig)
- assert m
- args = m.group(1)
- args = ", ".join(args.split(','))
- sig = sig.replace('(', '(space,')
- sig = ", ".join(sig.split(','))
- argc = len(args.split(','))
- unwrap_spec = ['ObjSpace']
- unwrap_spec += ['float'] * argc
- unwrap_spec = ", ".join(unwrap_spec)
- doc = func.__doc__.replace('\n', '\n ')
-
- print py.code.Source('''
- def %(sig)s:
- """%(doc)s
- """
- return space.wrap(math.%(name)s(%(args)s))
- %(name)s.unwrap_spec = [%(unwrap_spec)s]
- ''' % locals())
- names.append(name)
-
- print >>sys.stderr, py.code.Source("""
- # Package initialisation
- from pypy.interpreter.mixedmodule import MixedModule
-
- class Module(MixedModule):
- appleveldefs = {
- }
- interpleveldefs = {
- """)
-
- for name in names:
- space = " " * (15-len(name))
- print >>sys.stderr, (
- " %(name)r%(space)s: 'interp_math.%(name)s'," % locals())
- print >>sys.stderr, py.code.Source("""
- }
- """)
-
-
-
-
diff --git a/pypy/module/_ssl/interp_ssl.py b/pypy/module/_ssl/interp_ssl.py
--- a/pypy/module/_ssl/interp_ssl.py
+++ b/pypy/module/_ssl/interp_ssl.py
@@ -2,7 +2,7 @@
from pypy.interpreter.error import OperationError, new_exception_class
from pypy.interpreter.baseobjspace import W_Root, ObjSpace, Wrappable
from pypy.interpreter.typedef import TypeDef
-from pypy.interpreter.gateway import interp2app
+from pypy.interpreter.gateway import interp2app, unwrap_spec
from pypy.rlib import rpoll, rsocket
from pypy.rlib.ropenssl import *
@@ -78,6 +78,7 @@
if HAVE_OPENSSL_RAND:
# helper routines for seeding the SSL PRNG
+ @unwrap_spec(string=str, entropy=float)
def RAND_add(space, string, entropy):
"""RAND_add(string, entropy)
@@ -90,7 +91,6 @@
libssl_RAND_add(buf, len(string), entropy)
finally:
rffi.free_charp(buf)
- RAND_add.unwrap_spec = [ObjSpace, str, float]
def RAND_status(space):
"""RAND_status() -> 0 or 1
@@ -101,8 +101,8 @@
res = libssl_RAND_status()
return space.wrap(res)
- RAND_status.unwrap_spec = [ObjSpace]
+ @unwrap_spec(path=str)
def RAND_egd(space, path):
"""RAND_egd(path) -> bytes
@@ -120,7 +120,6 @@
msg += " enough data to seed the PRNG"
raise ssl_error(space, msg)
return space.wrap(bytes)
- RAND_egd.unwrap_spec = [ObjSpace, str]
class SSLObject(Wrappable):
def __init__(self, space):
@@ -137,11 +136,9 @@
def server(self):
return self.space.wrap(rffi.charp2str(self._server))
- server.unwrap_spec = ['self']
def issuer(self):
return self.space.wrap(rffi.charp2str(self._issuer))
- issuer.unwrap_spec = ['self']
def __del__(self):
if self.peer_cert:
@@ -153,6 +150,7 @@
lltype.free(self._server, flavor='raw')
lltype.free(self._issuer, flavor='raw')
+ @unwrap_spec(data='bufferstr')
def write(self, data):
"""write(s) -> len
@@ -201,8 +199,8 @@
return self.space.wrap(num_bytes)
else:
raise _ssl_seterror(self.space, self, num_bytes)
- write.unwrap_spec = ['self', 'bufferstr']
-
+
+ @unwrap_spec(num_bytes=int)
def read(self, num_bytes=1024):
"""read([len]) -> string
@@ -256,7 +254,6 @@
result = rffi.str_from_buffer(raw_buf, gc_buf, num_bytes, count)
rffi.keep_buffer_alive_until_here(raw_buf, gc_buf)
return self.space.wrap(result)
- read.unwrap_spec = ['self', int]
def _refresh_nonblocking(self, space):
# just in case the blocking state of the socket has been changed
@@ -375,17 +372,12 @@
SSLObject.typedef = TypeDef("SSLObject",
- server = interp2app(SSLObject.server,
- unwrap_spec=SSLObject.server.unwrap_spec),
- issuer = interp2app(SSLObject.issuer,
- unwrap_spec=SSLObject.issuer.unwrap_spec),
- write = interp2app(SSLObject.write,
- unwrap_spec=SSLObject.write.unwrap_spec),
- read = interp2app(SSLObject.read, unwrap_spec=SSLObject.read.unwrap_spec),
- do_handshake=interp2app(SSLObject.do_handshake,
- unwrap_spec=['self', ObjSpace]),
- shutdown=interp2app(SSLObject.shutdown,
- unwrap_spec=['self', ObjSpace]),
+ server = interp2app(SSLObject.server),
+ issuer = interp2app(SSLObject.issuer),
+ write = interp2app(SSLObject.write),
+ read = interp2app(SSLObject.read),
+ do_handshake=interp2app(SSLObject.do_handshake),
+ shutdown=interp2app(SSLObject.shutdown),
)
@@ -452,7 +444,6 @@
ss.w_socket = w_sock
return ss
-new_sslobject.unwrap_spec = [ObjSpace, W_Root, str, str]
def check_socket_and_wait_for_timeout(space, w_sock, writing):
"""If the socket has a timeout, do a select()/poll() on the socket.
@@ -553,14 +544,13 @@
return ssl_error(space, errstr, errval)
+ at unwrap_spec(side=int, cert_mode=int, protocol=int)
def sslwrap(space, w_socket, side, w_key_file=None, w_cert_file=None,
cert_mode=PY_SSL_CERT_NONE, protocol=PY_SSL_VERSION_SSL23,
w_cacerts_file=None, w_cipher=None):
"""sslwrap(socket, side, [keyfile, certfile]) -> sslobject"""
return space.wrap(new_sslobject(
space, w_socket, side, w_key_file, w_cert_file))
-sslwrap.unwrap_spec = [ObjSpace, W_Root, int, W_Root, W_Root,
- int, int, W_Root, W_Root]
class Cache:
def __init__(self, space):
More information about the Pypy-commit
mailing list