[pypy-commit] pypy numpy-record-dtypes: merge default
fijal
noreply at buildbot.pypy.org
Sun Mar 18 10:06:34 CET 2012
Author: Maciej Fijalkowski <fijall at gmail.com>
Branch: numpy-record-dtypes
Changeset: r53782:61df67e89afd
Date: 2012-03-18 11:05 +0200
http://bitbucket.org/pypy/pypy/changeset/61df67e89afd/
Log: merge default
diff --git a/lib_pypy/numpypy/core/numeric.py b/lib_pypy/numpypy/core/numeric.py
--- a/lib_pypy/numpypy/core/numeric.py
+++ b/lib_pypy/numpypy/core/numeric.py
@@ -6,7 +6,7 @@
import _numpypy as multiarray # ARGH
from numpypy.core.arrayprint import array2string
-
+newaxis = None
def asanyarray(a, dtype=None, order=None, maskna=None, ownmaskna=False):
"""
@@ -319,4 +319,4 @@
False_ = bool_(False)
True_ = bool_(True)
e = math.e
-pi = math.pi
\ No newline at end of file
+pi = math.pi
diff --git a/pypy/__init__.py b/pypy/__init__.py
--- a/pypy/__init__.py
+++ b/pypy/__init__.py
@@ -1,1 +1,16 @@
# Empty
+
+# XXX Should be empty again, soon.
+# XXX hack for win64:
+# This patch must stay here until the END OF STAGE 1
+# When all tests work, this branch will be merged
+# and the branch stage 2 is started, where we remove this patch.
+import sys
+if hasattr(sys, "maxsize"):
+ if sys.maxint != sys.maxsize:
+ sys.maxint = sys.maxsize
+ import warnings
+ warnings.warn("""\n
+---> This win64 port is now in stage 1: sys.maxint was modified.
+---> When pypy/__init__.py becomes empty again, we have reached stage 2.
+""")
diff --git a/pypy/interpreter/gateway.py b/pypy/interpreter/gateway.py
--- a/pypy/interpreter/gateway.py
+++ b/pypy/interpreter/gateway.py
@@ -901,15 +901,17 @@
def __init__(self, source, filename=None, modname='__builtin__'):
# HAAACK (but a good one)
+ self.filename = filename
+ self.source = str(py.code.Source(source).deindent())
+ self.modname = modname
if filename is None:
f = sys._getframe(1)
filename = '<%s:%d>' % (f.f_code.co_filename, f.f_lineno)
+ if not os.path.exists(filename):
+ # make source code available for tracebacks
+ lines = [x + "\n" for x in source.split("\n")]
+ py.std.linecache.cache[filename] = (1, None, lines, filename)
self.filename = filename
- self.source = str(py.code.Source(source).deindent())
- self.modname = modname
- # make source code available for tracebacks
- lines = [x + "\n" for x in source.split("\n")]
- py.std.linecache.cache[filename] = (1, None, lines, filename)
def __repr__(self):
return "<ApplevelClass filename=%r>" % (self.filename,)
diff --git a/pypy/jit/backend/x86/test/test_zmath.py b/pypy/jit/backend/x86/test/test_zmath.py
--- a/pypy/jit/backend/x86/test/test_zmath.py
+++ b/pypy/jit/backend/x86/test/test_zmath.py
@@ -6,6 +6,8 @@
from pypy.translator.c.test.test_genc import compile
from pypy.jit.backend.x86.support import ensure_sse2_floats
from pypy.rlib import rfloat
+from pypy.rlib.unroll import unrolling_iterable
+from pypy.rlib.debug import debug_print
def get_test_case((fnname, args, expected)):
@@ -16,16 +18,32 @@
expect_valueerror = (expected == ValueError)
expect_overflowerror = (expected == OverflowError)
check = test_direct.get_tester(expected)
+ unroll_args = unrolling_iterable(args)
#
def testfn():
+ debug_print('calling', fnname, 'with arguments:')
+ for arg in unroll_args:
+ debug_print('\t', arg)
try:
got = fn(*args)
except ValueError:
- return expect_valueerror
+ if expect_valueerror:
+ return True
+ else:
+ debug_print('unexpected ValueError!')
+ return False
except OverflowError:
- return expect_overflowerror
+ if expect_overflowerror:
+ return True
+ else:
+ debug_print('unexpected OverflowError!')
+ return False
else:
- return check(got)
+ if check(got):
+ return True
+ else:
+ debug_print('unexpected result:', got)
+ return False
#
testfn.func_name = 'test_' + fnname
return testfn
diff --git a/pypy/module/_ssl/test/test_ssl.py b/pypy/module/_ssl/test/test_ssl.py
--- a/pypy/module/_ssl/test/test_ssl.py
+++ b/pypy/module/_ssl/test/test_ssl.py
@@ -1,7 +1,6 @@
from pypy.conftest import gettestobjspace
import os
import py
-from pypy.rlib.rarithmetic import is_valid_int
class AppTestSSL:
@@ -31,7 +30,6 @@
assert isinstance(_ssl.SSL_ERROR_EOF, int)
assert isinstance(_ssl.SSL_ERROR_INVALID_ERROR_CODE, int)
- assert is_valid_int(_ssl.OPENSSL_VERSION_NUMBER)
assert isinstance(_ssl.OPENSSL_VERSION_INFO, tuple)
assert len(_ssl.OPENSSL_VERSION_INFO) == 5
assert isinstance(_ssl.OPENSSL_VERSION, str)
diff --git a/pypy/module/cpyext/pystate.py b/pypy/module/cpyext/pystate.py
--- a/pypy/module/cpyext/pystate.py
+++ b/pypy/module/cpyext/pystate.py
@@ -10,7 +10,7 @@
[('next', PyInterpreterState)],
PyInterpreterStateStruct)
PyThreadState = lltype.Ptr(cpython_struct(
- "PyThreadState",
+ "PyThreadState",
[('interp', PyInterpreterState),
('dict', PyObject),
]))
@@ -19,12 +19,15 @@
def PyEval_SaveThread(space):
"""Release the global interpreter lock (if it has been created and thread
support is enabled) and reset the thread state to NULL, returning the
- previous thread state (which is not NULL except in PyPy). If the lock has been created,
+ previous thread state. If the lock has been created,
the current thread must have acquired it. (This function is available even
when thread support is disabled at compile time.)"""
+ state = space.fromcache(InterpreterState)
if rffi.aroundstate.before:
rffi.aroundstate.before()
- return lltype.nullptr(PyThreadState.TO)
+ tstate = state.swap_thread_state(
+ space, lltype.nullptr(PyThreadState.TO))
+ return tstate
@cpython_api([PyThreadState], lltype.Void)
def PyEval_RestoreThread(space, tstate):
@@ -35,6 +38,8 @@
when thread support is disabled at compile time.)"""
if rffi.aroundstate.after:
rffi.aroundstate.after()
+ state = space.fromcache(InterpreterState)
+ state.swap_thread_state(space, tstate)
@cpython_api([], lltype.Void)
def PyEval_InitThreads(space):
@@ -67,28 +72,91 @@
dealloc=ThreadState_dealloc)
from pypy.interpreter.executioncontext import ExecutionContext
+
+# Keep track of the ThreadStateCapsule for a particular execution context. The
+# default is for new execution contexts not to have one; it is allocated on the
+# first cpyext-based request for it.
ExecutionContext.cpyext_threadstate = ThreadStateCapsule(None)
+# Also keep track of whether it has been initialized yet or not (None is a valid
+# PyThreadState for an execution context to have, when the GIL has been
+# released, so a check against that can't be used to determine the need for
+# initialization).
+ExecutionContext.cpyext_initialized_threadstate = False
+
+def cleanup_cpyext_state(self):
+ try:
+ del self.cpyext_threadstate
+ except AttributeError:
+ pass
+ self.cpyext_initialized_threadstate = False
+ExecutionContext.cleanup_cpyext_state = cleanup_cpyext_state
+
class InterpreterState(object):
def __init__(self, space):
self.interpreter_state = lltype.malloc(
PyInterpreterState.TO, flavor='raw', zero=True, immortal=True)
def new_thread_state(self, space):
+ """
+ Create a new ThreadStateCapsule to hold the PyThreadState for a
+ particular execution context.
+
+ :param space: A space.
+
+ :returns: A new ThreadStateCapsule holding a newly allocated
+ PyThreadState and referring to this interpreter state.
+ """
capsule = ThreadStateCapsule(space)
ts = capsule.memory
ts.c_interp = self.interpreter_state
ts.c_dict = make_ref(space, space.newdict())
return capsule
+
def get_thread_state(self, space):
+ """
+ Get the current PyThreadState for the current execution context.
+
+ :param space: A space.
+
+ :returns: The current PyThreadState for the current execution context,
+ or None if it does not have one.
+ """
ec = space.getexecutioncontext()
return self._get_thread_state(space, ec).memory
+
+ def swap_thread_state(self, space, tstate):
+ """
+ Replace the current thread state of the current execution context with a
+ new thread state.
+
+ :param space: The space.
+
+ :param tstate: The new PyThreadState for the current execution context.
+
+ :returns: The old thread state for the current execution context, either
+ None or a PyThreadState.
+ """
+ ec = space.getexecutioncontext()
+ capsule = self._get_thread_state(space, ec)
+ old_tstate = capsule.memory
+ capsule.memory = tstate
+ return old_tstate
+
def _get_thread_state(self, space, ec):
- if ec.cpyext_threadstate.memory == lltype.nullptr(PyThreadState.TO):
+ """
+ Get the ThreadStateCapsule for the given execution context, possibly
+ creating a new one if it does not already have one.
+
+ :param space: The space.
+ :param ec: The ExecutionContext of which to get the thread state.
+ :returns: The ThreadStateCapsule for the given execution context.
+ """
+ if not ec.cpyext_initialized_threadstate:
ec.cpyext_threadstate = self.new_thread_state(space)
-
+ ec.cpyext_initialized_threadstate = True
return ec.cpyext_threadstate
@cpython_api([], PyThreadState, error=CANNOT_FAIL)
@@ -105,13 +173,8 @@
def PyThreadState_Swap(space, tstate):
"""Swap the current thread state with the thread state given by the argument
tstate, which may be NULL. The global interpreter lock must be held."""
- # All cpyext calls release and acquire the GIL, so this function has no
- # side-effects
- if tstate:
- return lltype.nullptr(PyThreadState.TO)
- else:
- state = space.fromcache(InterpreterState)
- return state.get_thread_state(space)
+ state = space.fromcache(InterpreterState)
+ return state.swap_thread_state(space, tstate)
@cpython_api([PyThreadState], lltype.Void)
def PyEval_AcquireThread(space, tstate):
diff --git a/pypy/module/cpyext/src/getargs.c b/pypy/module/cpyext/src/getargs.c
--- a/pypy/module/cpyext/src/getargs.c
+++ b/pypy/module/cpyext/src/getargs.c
@@ -23,16 +23,33 @@
#define FLAG_COMPAT 1
#define FLAG_SIZE_T 2
+typedef int (*destr_t)(PyObject *, void *);
+
+
+/* Keep track of "objects" that have been allocated or initialized and
+ which will need to be deallocated or cleaned up somehow if overall
+ parsing fails.
+*/
+typedef struct {
+ void *item;
+ destr_t destructor;
+} freelistentry_t;
+
+typedef struct {
+ int first_available;
+ freelistentry_t *entries;
+} freelist_t;
+
/* Forward */
static int vgetargs1(PyObject *, const char *, va_list *, int);
static void seterror(int, const char *, int *, const char *, const char *);
static char *convertitem(PyObject *, const char **, va_list *, int, int *,
- char *, size_t, PyObject **);
+ char *, size_t, freelist_t *);
static char *converttuple(PyObject *, const char **, va_list *, int,
- int *, char *, size_t, int, PyObject **);
+ int *, char *, size_t, int, freelist_t *);
static char *convertsimple(PyObject *, const char **, va_list *, int, char *,
- size_t, PyObject **);
+ size_t, freelist_t *);
static Py_ssize_t convertbuffer(PyObject *, void **p, char **);
static int getbuffer(PyObject *, Py_buffer *, char**);
@@ -129,57 +146,56 @@
/* Handle cleanup of allocated memory in case of exception */
-static void
-cleanup_ptr(void *ptr)
+static int
+cleanup_ptr(PyObject *self, void *ptr)
{
- PyMem_FREE(ptr);
-}
-
-static void
-cleanup_buffer(void *ptr)
-{
- PyBuffer_Release((Py_buffer *) ptr);
+ if (ptr) {
+ PyMem_FREE(ptr);
+ }
+ return 0;
}
static int
-addcleanup(void *ptr, PyObject **freelist, void (*destr)(void *))
+cleanup_buffer(PyObject *self, void *ptr)
{
- PyObject *cobj;
- if (!*freelist) {
- *freelist = PyList_New(0);
- if (!*freelist) {
- destr(ptr);
- return -1;
- }
- }
- cobj = PyCObject_FromVoidPtr(ptr, destr);
- if (!cobj) {
- destr(ptr);
- return -1;
- }
- if (PyList_Append(*freelist, cobj)) {
- Py_DECREF(cobj);
- return -1;
- }
- Py_DECREF(cobj);
- return 0;
+ Py_buffer *buf = (Py_buffer *)ptr;
+ if (buf) {
+ PyBuffer_Release(buf);
+ }
+ return 0;
}
static int
-cleanreturn(int retval, PyObject *freelist)
+addcleanup(void *ptr, freelist_t *freelist, destr_t destructor)
{
- if (freelist && retval != 0) {
- /* We were successful, reset the destructors so that they
- don't get called. */
- Py_ssize_t len = PyList_GET_SIZE(freelist), i;
- for (i = 0; i < len; i++)
- ((PyCObject *) PyList_GET_ITEM(freelist, i))
- ->destructor = NULL;
- }
- Py_XDECREF(freelist);
- return retval;
+ int index;
+
+ index = freelist->first_available;
+ freelist->first_available += 1;
+
+ freelist->entries[index].item = ptr;
+ freelist->entries[index].destructor = destructor;
+
+ return 0;
}
+static int
+cleanreturn(int retval, freelist_t *freelist)
+{
+ int index;
+
+ if (retval == 0) {
+ /* A failure occurred, therefore execute all of the cleanup
+ functions.
+ */
+ for (index = 0; index < freelist->first_available; ++index) {
+ freelist->entries[index].destructor(NULL,
+ freelist->entries[index].item);
+ }
+ }
+ PyMem_Free(freelist->entries);
+ return retval;
+}
static int
vgetargs1(PyObject *args, const char *format, va_list *p_va, int flags)
@@ -195,7 +211,7 @@
const char *formatsave = format;
Py_ssize_t i, len;
char *msg;
- PyObject *freelist = NULL;
+ freelist_t freelist = {0, NULL};
int compat = flags & FLAG_COMPAT;
assert(compat || (args != (PyObject*)NULL));
@@ -251,16 +267,18 @@
format = formatsave;
+ freelist.entries = PyMem_New(freelistentry_t, max);
+
if (compat) {
if (max == 0) {
if (args == NULL)
- return 1;
+ return cleanreturn(1, &freelist);
PyOS_snprintf(msgbuf, sizeof(msgbuf),
"%.200s%s takes no arguments",
fname==NULL ? "function" : fname,
fname==NULL ? "" : "()");
PyErr_SetString(PyExc_TypeError, msgbuf);
- return 0;
+ return cleanreturn(0, &freelist);
}
else if (min == 1 && max == 1) {
if (args == NULL) {
@@ -269,26 +287,26 @@
fname==NULL ? "function" : fname,
fname==NULL ? "" : "()");
PyErr_SetString(PyExc_TypeError, msgbuf);
- return 0;
+ return cleanreturn(0, &freelist);
}
msg = convertitem(args, &format, p_va, flags, levels,
msgbuf, sizeof(msgbuf), &freelist);
if (msg == NULL)
- return cleanreturn(1, freelist);
+ return cleanreturn(1, &freelist);
seterror(levels[0], msg, levels+1, fname, message);
- return cleanreturn(0, freelist);
+ return cleanreturn(0, &freelist);
}
else {
PyErr_SetString(PyExc_SystemError,
"old style getargs format uses new features");
- return 0;
+ return cleanreturn(0, &freelist);
}
}
if (!PyTuple_Check(args)) {
PyErr_SetString(PyExc_SystemError,
"new style getargs format but argument is not a tuple");
- return 0;
+ return cleanreturn(0, &freelist);
}
len = PyTuple_GET_SIZE(args);
@@ -308,7 +326,7 @@
message = msgbuf;
}
PyErr_SetString(PyExc_TypeError, message);
- return 0;
+ return cleanreturn(0, &freelist);
}
for (i = 0; i < len; i++) {
@@ -319,7 +337,7 @@
sizeof(msgbuf), &freelist);
if (msg) {
seterror(i+1, msg, levels, fname, message);
- return cleanreturn(0, freelist);
+ return cleanreturn(0, &freelist);
}
}
@@ -328,10 +346,10 @@
*format != '|' && *format != ':' && *format != ';') {
PyErr_Format(PyExc_SystemError,
"bad format string: %.200s", formatsave);
- return cleanreturn(0, freelist);
+ return cleanreturn(0, &freelist);
}
- return cleanreturn(1, freelist);
+ return cleanreturn(1, &freelist);
}
@@ -395,7 +413,7 @@
static char *
converttuple(PyObject *arg, const char **p_format, va_list *p_va, int flags,
int *levels, char *msgbuf, size_t bufsize, int toplevel,
- PyObject **freelist)
+ freelist_t *freelist)
{
int level = 0;
int n = 0;
@@ -472,7 +490,7 @@
static char *
convertitem(PyObject *arg, const char **p_format, va_list *p_va, int flags,
- int *levels, char *msgbuf, size_t bufsize, PyObject **freelist)
+ int *levels, char *msgbuf, size_t bufsize, freelist_t *freelist)
{
char *msg;
const char *format = *p_format;
@@ -539,7 +557,7 @@
static char *
convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags,
- char *msgbuf, size_t bufsize, PyObject **freelist)
+ char *msgbuf, size_t bufsize, freelist_t *freelist)
{
/* For # codes */
#define FETCH_SIZE int *q=NULL;Py_ssize_t *q2=NULL;\
@@ -1501,7 +1519,9 @@
const char *fname, *msg, *custom_msg, *keyword;
int min = INT_MAX;
int i, len, nargs, nkeywords;
- PyObject *freelist = NULL, *current_arg;
+ PyObject *current_arg;
+ freelist_t freelist = {0, NULL};
+
assert(args != NULL && PyTuple_Check(args));
assert(keywords == NULL || PyDict_Check(keywords));
@@ -1525,6 +1545,8 @@
for (len=0; kwlist[len]; len++)
continue;
+ freelist.entries = PyMem_New(freelistentry_t, len);
+
nargs = PyTuple_GET_SIZE(args);
nkeywords = (keywords == NULL) ? 0 : PyDict_Size(keywords);
if (nargs + nkeywords > len) {
@@ -1535,7 +1557,7 @@
len,
(len == 1) ? "" : "s",
nargs + nkeywords);
- return 0;
+ return cleanreturn(0, &freelist);
}
/* convert tuple args and keyword args in same loop, using kwlist to drive process */
@@ -1549,7 +1571,7 @@
PyErr_Format(PyExc_RuntimeError,
"More keyword list entries (%d) than "
"format specifiers (%d)", len, i);
- return cleanreturn(0, freelist);
+ return cleanreturn(0, &freelist);
}
current_arg = NULL;
if (nkeywords) {
@@ -1563,11 +1585,11 @@
"Argument given by name ('%s') "
"and position (%d)",
keyword, i+1);
- return cleanreturn(0, freelist);
+ return cleanreturn(0, &freelist);
}
}
else if (nkeywords && PyErr_Occurred())
- return cleanreturn(0, freelist);
+ return cleanreturn(0, &freelist);
else if (i < nargs)
current_arg = PyTuple_GET_ITEM(args, i);
@@ -1576,7 +1598,7 @@
levels, msgbuf, sizeof(msgbuf), &freelist);
if (msg) {
seterror(i+1, msg, levels, fname, custom_msg);
- return cleanreturn(0, freelist);
+ return cleanreturn(0, &freelist);
}
continue;
}
@@ -1585,14 +1607,14 @@
PyErr_Format(PyExc_TypeError, "Required argument "
"'%s' (pos %d) not found",
keyword, i+1);
- return cleanreturn(0, freelist);
+ return cleanreturn(0, &freelist);
}
/* current code reports success when all required args
* fulfilled and no keyword args left, with no further
* validation. XXX Maybe skip this in debug build ?
*/
if (!nkeywords)
- return cleanreturn(1, freelist);
+ return cleanreturn(1, &freelist);
/* We are into optional args, skip thru to any remaining
* keyword args */
@@ -1600,7 +1622,7 @@
if (msg) {
PyErr_Format(PyExc_RuntimeError, "%s: '%s'", msg,
format);
- return cleanreturn(0, freelist);
+ return cleanreturn(0, &freelist);
}
}
@@ -1608,7 +1630,7 @@
PyErr_Format(PyExc_RuntimeError,
"more argument specifiers than keyword list entries "
"(remaining format:'%s')", format);
- return cleanreturn(0, freelist);
+ return cleanreturn(0, &freelist);
}
/* make sure there are no extraneous keyword arguments */
@@ -1621,7 +1643,7 @@
if (!PyString_Check(key)) {
PyErr_SetString(PyExc_TypeError,
"keywords must be strings");
- return cleanreturn(0, freelist);
+ return cleanreturn(0, &freelist);
}
ks = PyString_AsString(key);
for (i = 0; i < len; i++) {
@@ -1635,12 +1657,12 @@
"'%s' is an invalid keyword "
"argument for this function",
ks);
- return cleanreturn(0, freelist);
+ return cleanreturn(0, &freelist);
}
}
}
- return cleanreturn(1, freelist);
+ return cleanreturn(1, &freelist);
}
diff --git a/pypy/module/cpyext/test/test_cpyext.py b/pypy/module/cpyext/test/test_cpyext.py
--- a/pypy/module/cpyext/test/test_cpyext.py
+++ b/pypy/module/cpyext/test/test_cpyext.py
@@ -106,10 +106,7 @@
del obj
import gc; gc.collect()
- try:
- del space.getexecutioncontext().cpyext_threadstate
- except AttributeError:
- pass
+ space.getexecutioncontext().cleanup_cpyext_state()
for w_obj in state.non_heaptypes_w:
Py_DecRef(space, w_obj)
diff --git a/pypy/module/cpyext/test/test_pystate.py b/pypy/module/cpyext/test/test_pystate.py
--- a/pypy/module/cpyext/test/test_pystate.py
+++ b/pypy/module/cpyext/test/test_pystate.py
@@ -3,6 +3,10 @@
from pypy.rpython.lltypesystem.lltype import nullptr
from pypy.module.cpyext.pystate import PyInterpreterState, PyThreadState
from pypy.module.cpyext.pyobject import from_ref
+from pypy.rpython.lltypesystem import lltype
+from pypy.module.cpyext.test.test_cpyext import LeakCheckingTest, freeze_refcnts
+from pypy.module.cpyext.pystate import PyThreadState_Get, PyInterpreterState_Head
+from pypy.tool import leakfinder
class AppTestThreads(AppTestCpythonExtensionBase):
def test_allow_threads(self):
@@ -21,6 +25,93 @@
# Should compile at least
module.test()
+
+ def test_thread_state_get(self):
+ module = self.import_extension('foo', [
+ ("get", "METH_NOARGS",
+ """
+ PyThreadState *tstate = PyThreadState_Get();
+ if (tstate == NULL) {
+ return PyLong_FromLong(0);
+ }
+ if (tstate->interp != PyInterpreterState_Head()) {
+ return PyLong_FromLong(1);
+ }
+ if (tstate->interp->next != NULL) {
+ return PyLong_FromLong(2);
+ }
+ return PyLong_FromLong(3);
+ """),
+ ])
+ assert module.get() == 3
+
+ def test_basic_threadstate_dance(self):
+ module = self.import_extension('foo', [
+ ("dance", "METH_NOARGS",
+ """
+ PyThreadState *old_tstate, *new_tstate;
+
+ old_tstate = PyThreadState_Swap(NULL);
+ if (old_tstate == NULL) {
+ return PyLong_FromLong(0);
+ }
+
+ new_tstate = PyThreadState_Get();
+ if (new_tstate != NULL) {
+ return PyLong_FromLong(1);
+ }
+
+ new_tstate = PyThreadState_Swap(old_tstate);
+ if (new_tstate != NULL) {
+ return PyLong_FromLong(2);
+ }
+
+ new_tstate = PyThreadState_Get();
+ if (new_tstate != old_tstate) {
+ return PyLong_FromLong(3);
+ }
+
+ return PyLong_FromLong(4);
+ """),
+ ])
+ assert module.dance() == 4
+
+ def test_threadstate_dict(self):
+ module = self.import_extension('foo', [
+ ("getdict", "METH_NOARGS",
+ """
+ PyObject *dict = PyThreadState_GetDict();
+ Py_INCREF(dict);
+ return dict;
+ """),
+ ])
+ assert isinstance(module.getdict(), dict)
+
+ def test_savethread(self):
+ module = self.import_extension('foo', [
+ ("bounce", "METH_NOARGS",
+ """
+ PyThreadState *tstate = PyEval_SaveThread();
+ if (tstate == NULL) {
+ return PyLong_FromLong(0);
+ }
+
+ if (PyThreadState_Get() != NULL) {
+ return PyLong_FromLong(1);
+ }
+
+ PyEval_RestoreThread(tstate);
+
+ if (PyThreadState_Get() != tstate) {
+ return PyLong_FromLong(2);
+ }
+
+ return PyLong_FromLong(3);
+ """),
+ ])
+
+
+
class TestInterpreterState(BaseApiTest):
def test_interpreter_head(self, space, api):
state = api.PyInterpreterState_Head()
@@ -29,31 +120,3 @@
def test_interpreter_next(self, space, api):
state = api.PyInterpreterState_Head()
assert nullptr(PyInterpreterState.TO) == api.PyInterpreterState_Next(state)
-
-class TestThreadState(BaseApiTest):
- def test_thread_state_get(self, space, api):
- ts = api.PyThreadState_Get()
- assert ts != nullptr(PyThreadState.TO)
-
- def test_thread_state_interp(self, space, api):
- ts = api.PyThreadState_Get()
- assert ts.c_interp == api.PyInterpreterState_Head()
- assert ts.c_interp.c_next == nullptr(PyInterpreterState.TO)
-
- def test_basic_threadstate_dance(self, space, api):
- # Let extension modules call these functions,
- # Not sure of the semantics in pypy though.
- # (cpyext always acquires and releases the GIL around calls)
- tstate = api.PyThreadState_Swap(None)
- assert tstate is not None
- assert not api.PyThreadState_Swap(tstate)
-
- api.PyEval_AcquireThread(tstate)
- api.PyEval_ReleaseThread(tstate)
-
- def test_threadstate_dict(self, space, api):
- ts = api.PyThreadState_Get()
- ref = ts.c_dict
- assert ref == api.PyThreadState_GetDict()
- w_obj = from_ref(space, ref)
- assert space.isinstance_w(w_obj, space.w_dict)
diff --git a/pypy/module/math/test/test_direct.py b/pypy/module/math/test/test_direct.py
--- a/pypy/module/math/test/test_direct.py
+++ b/pypy/module/math/test/test_direct.py
@@ -59,6 +59,9 @@
('copysign', (1.5, -0.0), -1.5),
('copysign', (1.5, INFINITY), 1.5),
('copysign', (1.5, -INFINITY), -1.5),
+ ]
+ if sys.platform != 'win32': # all NaNs seem to be negative there...?
+ IRREGCASES += [
('copysign', (1.5, NAN), 1.5),
('copysign', (1.75, -NAN), -1.75), # special case for -NAN here
]
diff --git a/pypy/module/micronumpy/__init__.py b/pypy/module/micronumpy/__init__.py
--- a/pypy/module/micronumpy/__init__.py
+++ b/pypy/module/micronumpy/__init__.py
@@ -85,6 +85,7 @@
("arccos", "arccos"),
("arcsin", "arcsin"),
("arctan", "arctan"),
+ ("arctan2", "arctan2"),
("arccosh", "arccosh"),
("arcsinh", "arcsinh"),
("arctanh", "arctanh"),
@@ -95,7 +96,10 @@
("true_divide", "true_divide"),
("equal", "equal"),
("exp", "exp"),
+ ("exp2", "exp2"),
+ ("expm1", "expm1"),
("fabs", "fabs"),
+ ("fmod", "fmod"),
("floor", "floor"),
("ceil", "ceil"),
("greater", "greater"),
@@ -110,8 +114,10 @@
("radians", "radians"),
("degrees", "degrees"),
("deg2rad", "radians"),
+ ("rad2deg", "degrees"),
("reciprocal", "reciprocal"),
("sign", "sign"),
+ ("signbit", "signbit"),
("sin", "sin"),
("sinh", "sinh"),
("subtract", "subtract"),
@@ -124,6 +130,9 @@
('bitwise_not', 'invert'),
('isnan', 'isnan'),
('isinf', 'isinf'),
+ ('isneginf', 'isneginf'),
+ ('isposinf', 'isposinf'),
+ ('isfinite', 'isfinite'),
('logical_and', 'logical_and'),
('logical_xor', 'logical_xor'),
('logical_not', 'logical_not'),
@@ -134,6 +143,8 @@
('log1p', 'log1p'),
('power', 'power'),
('floor_divide', 'floor_divide'),
+ ('logaddexp', 'logaddexp'),
+ ('logaddexp2', 'logaddexp2'),
]:
interpleveldefs[exposed] = "interp_ufuncs.get(space).%s" % impl
diff --git a/pypy/module/micronumpy/interp_iter.py b/pypy/module/micronumpy/interp_iter.py
--- a/pypy/module/micronumpy/interp_iter.py
+++ b/pypy/module/micronumpy/interp_iter.py
@@ -2,7 +2,7 @@
from pypy.rlib import jit
from pypy.rlib.objectmodel import instantiate
from pypy.module.micronumpy.strides import calculate_broadcast_strides,\
- calculate_slice_strides, calculate_dot_strides
+ calculate_slice_strides, calculate_dot_strides, enumerate_chunks
""" This is a mini-tutorial on iterators, strides, and
memory layout. It assumes you are familiar with the terms, see
@@ -73,7 +73,7 @@
def extend_shape(self, old_shape):
shape = []
i = -1
- for i, c in enumerate(self.l):
+ for i, c in enumerate_chunks(self.l):
if c.step != 0:
shape.append(c.lgt)
s = i + 1
@@ -95,6 +95,8 @@
class Chunk(BaseChunk):
+ axis_step = 1
+
def __init__(self, start, stop, step, lgt):
self.start = start
self.stop = stop
@@ -105,6 +107,16 @@
return 'Chunk(%d, %d, %d, %d)' % (self.start, self.stop, self.step,
self.lgt)
+class NewAxisChunk(Chunk):
+ start = 0
+ stop = 1
+ step = 1
+ lgt = 1
+ axis_step = 0
+
+ def __init__(self):
+ pass
+
class BaseTransform(object):
pass
diff --git a/pypy/module/micronumpy/interp_numarray.py b/pypy/module/micronumpy/interp_numarray.py
--- a/pypy/module/micronumpy/interp_numarray.py
+++ b/pypy/module/micronumpy/interp_numarray.py
@@ -7,7 +7,8 @@
from pypy.module.micronumpy.appbridge import get_appbridge_cache
from pypy.module.micronumpy.dot import multidim_dot, match_dot_shapes
from pypy.module.micronumpy.interp_iter import (ArrayIterator,
- SkipLastAxisIterator, Chunk, ViewIterator, Chunks, RecordChunk)
+ SkipLastAxisIterator, Chunk, ViewIterator, Chunks, RecordChunk,
+ NewAxisChunk)
from pypy.module.micronumpy.strides import (shape_agreement,
find_shape_and_elems, get_shape_from_iterable, calc_new_strides, to_coords)
from pypy.rlib import jit
@@ -324,6 +325,13 @@
if space.isinstance_w(w_idx, space.w_str):
return False
shape_len = len(self.shape)
+ if space.isinstance_w(w_idx, space.w_tuple):
+ for w_item in space.fixedview(w_idx):
+ if (space.isinstance_w(w_item, space.w_slice) or
+ space.is_w(w_item, space.w_None)):
+ return False
+ elif space.is_w(w_idx, space.w_None):
+ return False
if shape_len == 0:
raise OperationError(space.w_IndexError, space.wrap(
"0-d arrays can't be indexed"))
@@ -339,12 +347,7 @@
if lgt > shape_len:
raise OperationError(space.w_IndexError,
space.wrap("invalid index"))
- if lgt < shape_len:
- return False
- for w_item in space.fixedview(w_idx):
- if space.isinstance_w(w_item, space.w_slice):
- return False
- return True
+ return lgt == shape_len
@jit.unroll_safe
def _prepare_slice_args(self, space, w_idx):
@@ -358,8 +361,18 @@
if (space.isinstance_w(w_idx, space.w_int) or
space.isinstance_w(w_idx, space.w_slice)):
return Chunks([Chunk(*space.decode_index4(w_idx, self.shape[0]))])
- return Chunks([Chunk(*space.decode_index4(w_item, self.shape[i])) for i, w_item in
- enumerate(space.fixedview(w_idx))])
+ elif space.is_w(w_idx, space.w_None):
+ return Chunks([NewAxisChunk()])
+ result = []
+ i = 0
+ for w_item in space.fixedview(w_idx):
+ if space.is_w(w_item, space.w_None):
+ result.append(NewAxisChunk())
+ else:
+ result.append(Chunk(*space.decode_index4(w_item,
+ self.shape[i])))
+ i += 1
+ return Chunks(result)
def count_all_true(self):
sig = self.find_sig()
@@ -471,8 +484,10 @@
def reshape(self, space, new_shape):
concrete = self.get_concrete()
- # Since we got to here, prod(new_shape) == self.get_size()
- new_strides = calc_new_strides(new_shape, concrete.shape,
+ # Since we got to here, prod(new_shape) == self.size
+ new_strides = None
+ if self.size > 0:
+ new_strides = calc_new_strides(new_shape, concrete.shape,
concrete.strides, concrete.order)
if new_strides:
# We can create a view, strides somehow match up.
@@ -1044,7 +1059,7 @@
def setshape(self, space, new_shape):
if len(self.shape) < 1:
return
- elif len(self.shape) < 2:
+ elif len(self.shape) < 2 or self.size < 1:
# TODO: this code could be refactored into calc_strides
# but then calc_strides would have to accept a stepping factor
strides = []
@@ -1056,7 +1071,7 @@
for sh in new_shape:
strides.append(s * dtype.get_size())
backstrides.append(s * (sh - 1) * dtype.get_size())
- s *= sh
+ s *= max(1, sh)
if self.order == 'C':
strides.reverse()
backstrides.reverse()
diff --git a/pypy/module/micronumpy/interp_ufuncs.py b/pypy/module/micronumpy/interp_ufuncs.py
--- a/pypy/module/micronumpy/interp_ufuncs.py
+++ b/pypy/module/micronumpy/interp_ufuncs.py
@@ -404,6 +404,9 @@
("greater_equal", "ge", 2, {"comparison_func": True}),
("isnan", "isnan", 1, {"bool_result": True}),
("isinf", "isinf", 1, {"bool_result": True}),
+ ("isneginf", "isneginf", 1, {"bool_result": True}),
+ ("isposinf", "isposinf", 1, {"bool_result": True}),
+ ("isfinite", "isfinite", 1, {"bool_result": True}),
('logical_and', 'logical_and', 2, {'comparison_func': True,
'identity': 1}),
@@ -421,12 +424,16 @@
("negative", "neg", 1),
("absolute", "abs", 1),
("sign", "sign", 1, {"promote_bools": True}),
+ ("signbit", "signbit", 1, {"bool_result": True}),
("reciprocal", "reciprocal", 1),
("fabs", "fabs", 1, {"promote_to_float": True}),
+ ("fmod", "fmod", 2, {"promote_to_float": True}),
("floor", "floor", 1, {"promote_to_float": True}),
("ceil", "ceil", 1, {"promote_to_float": True}),
("exp", "exp", 1, {"promote_to_float": True}),
+ ("exp2", "exp2", 1, {"promote_to_float": True}),
+ ("expm1", "expm1", 1, {"promote_to_float": True}),
('sqrt', 'sqrt', 1, {'promote_to_float': True}),
@@ -436,6 +443,7 @@
("arcsin", "arcsin", 1, {"promote_to_float": True}),
("arccos", "arccos", 1, {"promote_to_float": True}),
("arctan", "arctan", 1, {"promote_to_float": True}),
+ ("arctan2", "arctan2", 2, {"promote_to_float": True}),
("sinh", "sinh", 1, {"promote_to_float": True}),
("cosh", "cosh", 1, {"promote_to_float": True}),
("tanh", "tanh", 1, {"promote_to_float": True}),
@@ -450,6 +458,8 @@
("log2", "log2", 1, {"promote_to_float": True}),
("log10", "log10", 1, {"promote_to_float": True}),
("log1p", "log1p", 1, {"promote_to_float": True}),
+ ("logaddexp", "logaddexp", 2, {"promote_to_float": True}),
+ ("logaddexp2", "logaddexp2", 2, {"promote_to_float": True}),
]:
self.add_ufunc(space, *ufunc_def)
diff --git a/pypy/module/micronumpy/strides.py b/pypy/module/micronumpy/strides.py
--- a/pypy/module/micronumpy/strides.py
+++ b/pypy/module/micronumpy/strides.py
@@ -1,6 +1,14 @@
from pypy.rlib import jit
from pypy.interpreter.error import OperationError
+def enumerate_chunks(chunks):
+ result = []
+ i = -1
+ for chunk in chunks:
+ i += chunk.axis_step
+ result.append((i, chunk))
+ return result
+
@jit.look_inside_iff(lambda shape, start, strides, backstrides, chunks:
jit.isconstant(len(chunks))
)
@@ -10,7 +18,7 @@
rstart = start
rshape = []
i = -1
- for i, chunk in enumerate(chunks):
+ for i, chunk in enumerate_chunks(chunks):
if chunk.step != 0:
rstrides.append(strides[i] * chunk.step)
rbackstrides.append(strides[i] * (chunk.lgt - 1) * chunk.step)
diff --git a/pypy/module/micronumpy/test/test_numarray.py b/pypy/module/micronumpy/test/test_numarray.py
--- a/pypy/module/micronumpy/test/test_numarray.py
+++ b/pypy/module/micronumpy/test/test_numarray.py
@@ -382,6 +382,58 @@
assert a[1] == 0.
assert a[3] == 0.
+ def test_newaxis(self):
+ from _numpypy import array
+ from numpypy.core.numeric import newaxis
+ a = array(range(5))
+ b = array([range(5)])
+ assert (a[newaxis] == b).all()
+
+ def test_newaxis_slice(self):
+ from _numpypy import array
+ from numpypy.core.numeric import newaxis
+
+ a = array(range(5))
+ b = array(range(1,5))
+ c = array([range(1,5)])
+ d = array([[x] for x in range(1,5)])
+
+ assert (a[1:] == b).all()
+ assert (a[1:,newaxis] == d).all()
+ assert (a[newaxis,1:] == c).all()
+
+ def test_newaxis_assign(self):
+ from _numpypy import array
+ from numpypy.core.numeric import newaxis
+
+ a = array(range(5))
+ a[newaxis,1] = [2]
+ assert a[1] == 2
+
+ def test_newaxis_virtual(self):
+ from _numpypy import array
+ from numpypy.core.numeric import newaxis
+
+ a = array(range(5))
+ b = (a + a)[newaxis]
+ c = array([[0, 2, 4, 6, 8]])
+ assert (b == c).all()
+
+ def test_newaxis_then_slice(self):
+ from _numpypy import array
+ from numpypy.core.numeric import newaxis
+ a = array(range(5))
+ b = a[newaxis]
+ assert b.shape == (1, 5)
+ assert (b[0,1:] == a[1:]).all()
+
+ def test_slice_then_newaxis(self):
+ from _numpypy import array
+ from numpypy.core.numeric import newaxis
+ a = array(range(5))
+ b = a[2:]
+ assert (b[newaxis] == [[2, 3, 4]]).all()
+
def test_scalar(self):
from _numpypy import array, dtype
a = array(3)
@@ -442,6 +494,8 @@
a = zeros((4, 2, 3))
a.shape = (12, 2)
(a + a).reshape(2, 12) # assert did not explode
+ a = array([[[[]]]])
+ assert a.reshape((0,)).shape == (0,)
def test_slice_reshape(self):
from _numpypy import zeros, arange
diff --git a/pypy/module/micronumpy/test/test_ufuncs.py b/pypy/module/micronumpy/test/test_ufuncs.py
--- a/pypy/module/micronumpy/test/test_ufuncs.py
+++ b/pypy/module/micronumpy/test/test_ufuncs.py
@@ -113,14 +113,37 @@
assert (divide(array([-10]), array([2])) == array([-5])).all()
+ def test_true_divide(self):
+ from _numpypy import array, true_divide
+
+ a = array([0, 1, 2, 3, 4, 1, -1])
+ b = array([4, 4, 4, 4, 4, 0, 0])
+ c = true_divide(a, b)
+ assert (c == [0.0, 0.25, 0.5, 0.75, 1.0, float('inf'), float('-inf')]).all()
+
+ assert math.isnan(true_divide(0, 0))
+
def test_fabs(self):
from _numpypy import array, fabs
- from math import fabs as math_fabs
+ from math import fabs as math_fabs, isnan
a = array([-5.0, -0.0, 1.0])
b = fabs(a)
for i in range(3):
assert b[i] == math_fabs(a[i])
+ assert fabs(float('inf')) == float('inf')
+ assert fabs(float('-inf')) == float('inf')
+ assert isnan(fabs(float('nan')))
+
+ def test_fmod(self):
+ from _numpypy import fmod
+ import math
+
+ assert fmod(-1e-100, 1e100) == -1e-100
+ assert fmod(3, float('inf')) == 3
+ assert (fmod([-3, -2, -1, 1, 2, 3], 2) == [-1, 0, -1, 1, 0, 1]).all()
+ for v in [float('inf'), float('-inf'), float('nan'), float('-nan')]:
+ assert math.isnan(fmod(v, 2))
def test_minimum(self):
from _numpypy import array, minimum
@@ -172,6 +195,15 @@
assert a[0] == 1
assert a[1] == 0
+ def test_signbit(self):
+ from _numpypy import signbit, copysign
+ import struct
+
+ assert (signbit([0, 0.0, 1, 1.0, float('inf'), float('nan')]) ==
+ [False, False, False, False, False, False]).all()
+ assert (signbit([-0, -0.0, -1, -1.0, float('-inf'), -float('nan'), float('-nan')]) ==
+ [False, True, True, True, True, True, True]).all()
+
def test_reciporocal(self):
from _numpypy import array, reciprocal
@@ -231,13 +263,46 @@
a = array([-5.0, -0.0, 0.0, 12345678.0, float("inf"),
-float('inf'), -12343424.0])
b = exp(a)
- for i in range(4):
+ for i in range(len(a)):
try:
res = math.exp(a[i])
except OverflowError:
res = float('inf')
assert b[i] == res
+ def test_exp2(self):
+ import math
+ from _numpypy import array, exp2
+
+ a = array([-5.0, -0.0, 0.0, 2, 12345678.0, float("inf"),
+ -float('inf'), -12343424.0])
+ b = exp2(a)
+ for i in range(len(a)):
+ try:
+ res = 2 ** a[i]
+ except OverflowError:
+ res = float('inf')
+ assert b[i] == res
+
+ assert exp2(3) == 8
+ assert math.isnan(exp2(float("nan")))
+
+ def test_expm1(self):
+ import math
+ from _numpypy import array, expm1
+
+ a = array([-5.0, -0.0, 0.0, 12345678.0, float("inf"),
+ -float('inf'), -12343424.0])
+ b = expm1(a)
+ for i in range(4):
+ try:
+ res = math.exp(a[i]) - 1
+ except OverflowError:
+ res = float('inf')
+ assert b[i] == res
+
+ assert expm1(1e-50) == 1e-50
+
def test_sin(self):
import math
from _numpypy import array, sin
@@ -310,6 +375,21 @@
b = arctan(a)
assert math.isnan(b[0])
+ def test_arctan2(self):
+ import math
+ from _numpypy import array, arctan2
+
+ # From the numpy documentation
+ assert (
+ arctan2(
+ [0., 0., 1., -1., float('inf'), float('inf')],
+ [0., -0., float('inf'), float('inf'), float('inf'), float('-inf')]) ==
+ [0., math.pi, 0., -0., math.pi/4, 3*math.pi/4]).all()
+
+ a = array([float('nan')])
+ b = arctan2(a, 0)
+ assert math.isnan(b[0])
+
def test_sinh(self):
import math
from _numpypy import array, sinh
@@ -415,6 +495,19 @@
for i in range(len(a)):
assert b[i] == math.degrees(a[i])
+ def test_rad2deg(self):
+ import math
+ from _numpypy import rad2deg, array
+ a = array([
+ -181, -180, -179,
+ 181, 180, 179,
+ 359, 360, 361,
+ 400, -1, 0, 1,
+ float('inf'), float('-inf')])
+ b = rad2deg(a)
+ for i in range(len(a)):
+ assert b[i] == math.degrees(a[i])
+
def test_reduce_errors(self):
from _numpypy import sin, add
@@ -510,6 +603,26 @@
assert (isinf(array([0.2, float('inf'), float('nan')])) == [False, True, False]).all()
assert isinf(array([0.2])).dtype.kind == 'b'
+ def test_isposinf_isneginf(self):
+ from _numpypy import isneginf, isposinf
+ assert isposinf(float('inf'))
+ assert not isposinf(float('-inf'))
+ assert not isposinf(float('nan'))
+ assert not isposinf(0)
+ assert not isposinf(0.0)
+ assert isneginf(float('-inf'))
+ assert not isneginf(float('inf'))
+ assert not isneginf(float('nan'))
+ assert not isneginf(0)
+ assert not isneginf(0.0)
+
+ def test_isfinite(self):
+ from _numpypy import isfinite
+ assert (isfinite([0, 0.0, 1e50, -1e-50]) ==
+ [True, True, True, True]).all()
+ assert (isfinite([float('-inf'), float('inf'), float('-nan'), float('nan')]) ==
+ [False, False, False, False]).all()
+
def test_logical_ops(self):
from _numpypy import logical_and, logical_or, logical_xor, logical_not
@@ -544,7 +657,7 @@
assert log1p(float('inf')) == float('inf')
assert (log1p([0, 1e-50, math.e - 1]) == [0, 1e-50, 1]).all()
- def test_power(self):
+ def test_power_float(self):
import math
from _numpypy import power, array
a = array([1., 2., 3.])
@@ -558,9 +671,94 @@
for i in range(len(a)):
assert c[i] == a[i] ** b[i]
+ assert power(2, float('inf')) == float('inf')
+ assert power(float('inf'), float('inf')) == float('inf')
+ assert power(12345.0, 12345.0) == float('inf')
+ assert power(-12345.0, 12345.0) == float('-inf')
+ assert power(-12345.0, 12346.0) == float('inf')
+ assert math.isnan(power(-1, 1.1))
+ assert math.isnan(power(-1, -1.1))
+ assert power(-2.0, -1) == -0.5
+ assert power(-2.0, -2) == 0.25
+ assert power(12345.0, -12345.0) == 0
+ assert power(float('-inf'), 2) == float('inf')
+ assert power(float('-inf'), 2.5) == float('inf')
+ assert power(float('-inf'), 3) == float('-inf')
+
+ def test_power_int(self):
+ import math
+ from _numpypy import power, array
+ a = array([1, 2, 3])
+ b = power(a, 3)
+ for i in range(len(a)):
+ assert b[i] == a[i] ** 3
+
+ a = array([1, 2, 3])
+ b = array([1, 2, 3])
+ c = power(a, b)
+ for i in range(len(a)):
+ assert c[i] == a[i] ** b[i]
+
+ # assert power(12345, 12345) == -9223372036854775808
+ # assert power(-12345, 12345) == -9223372036854775808
+ # assert power(-12345, 12346) == -9223372036854775808
+ assert power(2, 0) == 1
+ assert power(2, -1) == 0
+ assert power(2, -2) == 0
+ assert power(-2, -1) == 0
+ assert power(-2, -2) == 0
+ assert power(12345, -12345) == 0
+
def test_floordiv(self):
from _numpypy import floor_divide, array
a = array([1., 2., 3., 4., 5., 6., 6.01])
b = floor_divide(a, 2.5)
for i in range(len(a)):
assert b[i] == a[i] // 2.5
+
+ def test_logaddexp(self):
+ import math
+ from _numpypy import logaddexp
+
+ # From the numpy documentation
+ prob1 = math.log(1e-50)
+ prob2 = math.log(2.5e-50)
+ prob12 = logaddexp(prob1, prob2)
+ assert math.fabs(-113.87649168120691 - prob12) < 0.000000000001
+
+ assert logaddexp(0, 0) == math.log(2)
+ assert logaddexp(float('-inf'), 0) == 0
+ assert logaddexp(12345678, 12345678) == float('inf')
+
+ assert math.isnan(logaddexp(float('nan'), 1))
+ assert math.isnan(logaddexp(1, float('nan')))
+ assert math.isnan(logaddexp(float('nan'), float('inf')))
+ assert math.isnan(logaddexp(float('inf'), float('nan')))
+ assert logaddexp(float('-inf'), float('-inf')) == float('-inf')
+ assert logaddexp(float('-inf'), float('inf')) == float('inf')
+ assert logaddexp(float('inf'), float('-inf')) == float('inf')
+ assert logaddexp(float('inf'), float('inf')) == float('inf')
+
+ def test_logaddexp2(self):
+ import math
+ from _numpypy import logaddexp2
+ log2 = math.log(2)
+
+ # From the numpy documentation
+ prob1 = math.log(1e-50) / log2
+ prob2 = math.log(2.5e-50) / log2
+ prob12 = logaddexp2(prob1, prob2)
+ assert math.fabs(-164.28904982231052 - prob12) < 0.000000000001
+
+ assert logaddexp2(0, 0) == 1
+ assert logaddexp2(float('-inf'), 0) == 0
+ assert logaddexp2(12345678, 12345678) == float('inf')
+
+ assert math.isnan(logaddexp2(float('nan'), 1))
+ assert math.isnan(logaddexp2(1, float('nan')))
+ assert math.isnan(logaddexp2(float('nan'), float('inf')))
+ assert math.isnan(logaddexp2(float('inf'), float('nan')))
+ assert logaddexp2(float('-inf'), float('-inf')) == float('-inf')
+ assert logaddexp2(float('-inf'), float('inf')) == float('inf')
+ assert logaddexp2(float('inf'), float('-inf')) == float('inf')
+ assert logaddexp2(float('inf'), float('inf')) == float('inf')
diff --git a/pypy/module/micronumpy/types.py b/pypy/module/micronumpy/types.py
--- a/pypy/module/micronumpy/types.py
+++ b/pypy/module/micronumpy/types.py
@@ -178,6 +178,14 @@
def isinf(self, v):
return False
+ @raw_unary_op
+ def isneginf(self, v):
+ return False
+
+ @raw_unary_op
+ def isposinf(self, v):
+ return False
+
@raw_binary_op
def eq(self, v1, v2):
return v1 == v2
@@ -329,6 +337,8 @@
@simple_binary_op
def pow(self, v1, v2):
+ if v2 < 0:
+ return 0
res = 1
while v2 > 0:
if v2 & 1:
@@ -525,7 +535,15 @@
@simple_binary_op
def pow(self, v1, v2):
- return math.pow(v1, v2)
+ try:
+ return math.pow(v1, v2)
+ except ValueError:
+ return rfloat.NAN
+ except OverflowError:
+ if math.modf(v2)[0] == 0 and math.modf(v2 / 2)[0] != 0:
+ # Odd integer powers result in the same sign as the base
+ return rfloat.copysign(rfloat.INFINITY, v1)
+ return rfloat.INFINITY
@simple_binary_op
def copysign(self, v1, v2):
@@ -537,10 +555,21 @@
return 0.0
return rfloat.copysign(1.0, v)
+ @raw_unary_op
+ def signbit(self, v):
+ return rfloat.copysign(1.0, v) < 0.0
+
@simple_unary_op
def fabs(self, v):
return math.fabs(v)
+ @simple_binary_op
+ def fmod(self, v1, v2):
+ try:
+ return math.fmod(v1, v2)
+ except ValueError:
+ return rfloat.NAN
+
@simple_unary_op
def reciprocal(self, v):
if v == 0.0:
@@ -563,6 +592,20 @@
return rfloat.INFINITY
@simple_unary_op
+ def exp2(self, v):
+ try:
+ return math.pow(2, v)
+ except OverflowError:
+ return rfloat.INFINITY
+
+ @simple_unary_op
+ def expm1(self, v):
+ try:
+ return rfloat.expm1(v)
+ except OverflowError:
+ return rfloat.INFINITY
+
+ @simple_unary_op
def sin(self, v):
return math.sin(v)
@@ -590,6 +633,10 @@
def arctan(self, v):
return math.atan(v)
+ @simple_binary_op
+ def arctan2(self, v1, v2):
+ return math.atan2(v1, v2)
+
@simple_unary_op
def sinh(self, v):
return math.sinh(v)
@@ -635,6 +682,18 @@
def isinf(self, v):
return rfloat.isinf(v)
+ @raw_unary_op
+ def isneginf(self, v):
+ return rfloat.isinf(v) and v < 0
+
+ @raw_unary_op
+ def isposinf(self, v):
+ return rfloat.isinf(v) and v > 0
+
+ @raw_unary_op
+ def isfinite(self, v):
+ return not (rfloat.isinf(v) or rfloat.isnan(v))
+
@simple_unary_op
def radians(self, v):
return v * degToRad
@@ -686,6 +745,48 @@
except ValueError:
return rfloat.NAN
+ @simple_binary_op
+ def logaddexp(self, v1, v2):
+ try:
+ v1e = math.exp(v1)
+ except OverflowError:
+ v1e = rfloat.INFINITY
+ try:
+ v2e = math.exp(v2)
+ except OverflowError:
+ v2e = rfloat.INFINITY
+
+ v12e = v1e + v2e
+ try:
+ return math.log(v12e)
+ except ValueError:
+ if v12e == 0.0:
+ # CPython raises ValueError here, so we have to check
+ # the value to find the correct numpy return value
+ return -rfloat.INFINITY
+ return rfloat.NAN
+
+ @simple_binary_op
+ def logaddexp2(self, v1, v2):
+ try:
+ v1e = math.pow(2, v1)
+ except OverflowError:
+ v1e = rfloat.INFINITY
+ try:
+ v2e = math.pow(2, v2)
+ except OverflowError:
+ v2e = rfloat.INFINITY
+
+ v12e = v1e + v2e
+ try:
+ return math.log(v12e) / log2
+ except ValueError:
+ if v12e == 0.0:
+ # CPython raises ValueError here, so we have to check
+ # the value to find the correct numpy return value
+ return -rfloat.INFINITY
+ return rfloat.NAN
+
class NonNativeFloat(NonNativePrimitive, Float):
_mixin_ = True
@@ -803,8 +904,6 @@
UIntP = tp
break
del tp
-assert rffi.sizeof(IntP) == rffi.sizeof(rffi.VOIDP)
-assert rffi.sizeof(UIntP) == rffi.sizeof(rffi.VOIDP)
def _setup():
# compute alignment
diff --git a/pypy/objspace/flow/model.py b/pypy/objspace/flow/model.py
--- a/pypy/objspace/flow/model.py
+++ b/pypy/objspace/flow/model.py
@@ -8,7 +8,7 @@
from pypy.tool.descriptor import roproperty
from pypy.tool.sourcetools import PY_IDENTIFIER, nice_repr_for_func
from pypy.tool.identity_dict import identity_dict
-from pypy.rlib.rarithmetic import is_valid_int
+from pypy.rlib.rarithmetic import is_valid_int, r_longlong, r_ulonglong
"""
@@ -546,6 +546,8 @@
for n in cases[:len(cases)-has_default]:
if is_valid_int(n):
continue
+ if isinstance(n, (r_longlong, r_ulonglong)):
+ continue
if isinstance(n, (str, unicode)) and len(n) == 1:
continue
assert n != 'default', (
diff --git a/pypy/objspace/std/complexobject.py b/pypy/objspace/std/complexobject.py
--- a/pypy/objspace/std/complexobject.py
+++ b/pypy/objspace/std/complexobject.py
@@ -9,6 +9,7 @@
from pypy.rlib.rfloat import (
formatd, DTSF_STR_PRECISION, isinf, isnan, copysign)
from pypy.rlib import jit
+from pypy.rlib.rarithmetic import intmask
import math
@@ -173,7 +174,7 @@
def hash__Complex(space, w_value):
hashreal = _hash_float(space, w_value.realval)
hashimg = _hash_float(space, w_value.imagval)
- combined = hashreal + 1000003 * hashimg
+ combined = intmask(hashreal + 1000003 * hashimg)
return space.newint(combined)
def add__Complex_Complex(space, w_complex1, w_complex2):
diff --git a/pypy/objspace/std/test/test_smallintobject.py b/pypy/objspace/std/test/test_smallintobject.py
--- a/pypy/objspace/std/test/test_smallintobject.py
+++ b/pypy/objspace/std/test/test_smallintobject.py
@@ -64,7 +64,7 @@
f1 = wrapint(self.space, x)
f2 = wrapint(self.space, y)
result = self.space.unwrap(self.space.add(f1, f2))
- assert result == x+y and type(result) == type(x+y)
+ assert result == x+y
def test_sub(self):
for x in [1, 100, sys.maxint // 2 - 50,
@@ -74,15 +74,16 @@
f1 = wrapint(self.space, x)
f2 = wrapint(self.space, y)
result = self.space.unwrap(self.space.sub(f1, f2))
- assert result == x-y and type(result) == type(x-y)
-
+ assert result == x-y
+
def test_mul(self):
for x in [0, 1, 100, sys.maxint // 2 - 50, sys.maxint - 1000]:
for y in [0, 1, 100, sys.maxint // 2 - 50, sys.maxint - 1000]:
f1 = wrapint(self.space, x)
f2 = wrapint(self.space, y)
result = self.space.unwrap(self.space.mul(f1, f2))
- assert result == x*y and type(result) == type(x*y)
+ assert result == x*y
+
def test_div(self):
for i in range(10):
diff --git a/pypy/objspace/std/test/test_userobject.py b/pypy/objspace/std/test/test_userobject.py
--- a/pypy/objspace/std/test/test_userobject.py
+++ b/pypy/objspace/std/test/test_userobject.py
@@ -10,10 +10,10 @@
from pypy import conftest
cls.space = conftest.gettestobjspace(**cls.OPTIONS)
cls.w_runappdirect = cls.space.wrap(bool(conftest.option.runappdirect))
-
- def w_rand(self):
- import random
- return random.randrange(0, 5)
+ def rand(space):
+ import random
+ return space.wrap(random.randrange(0, 5))
+ cls.w_rand = cls.space.wrap(gateway.interp2app(rand))
def test_emptyclass(self):
class empty(object): pass
diff --git a/pypy/rlib/libffi.py b/pypy/rlib/libffi.py
--- a/pypy/rlib/libffi.py
+++ b/pypy/rlib/libffi.py
@@ -35,6 +35,7 @@
cls.ulong = clibffi.cast_type_to_ffitype(rffi.ULONG)
cls.slonglong = clibffi.cast_type_to_ffitype(rffi.LONGLONG)
cls.ulonglong = clibffi.cast_type_to_ffitype(rffi.ULONGLONG)
+ cls.signed = clibffi.cast_type_to_ffitype(rffi.SIGNED)
cls.wchar_t = clibffi.cast_type_to_ffitype(lltype.UniChar)
del cls._import
@@ -79,16 +80,20 @@
types._import()
+# this was '_fits_into_long', which is not adequate, because long is
+# not necessary the type where we compute with. Actually meant is
+# the type 'Signed'.
+
@specialize.arg(0)
-def _fits_into_long(TYPE):
+def _fits_into_signed(TYPE):
if isinstance(TYPE, lltype.Ptr):
- return True # pointers always fits into longs
+ return True # pointers always fits into Signeds
if not isinstance(TYPE, lltype.Primitive):
return False
if TYPE is lltype.Void or TYPE is rffi.FLOAT or TYPE is rffi.DOUBLE:
return False
sz = rffi.sizeof(TYPE)
- return sz <= rffi.sizeof(rffi.LONG)
+ return sz <= rffi.sizeof(rffi.SIGNED)
# ======================================================================
@@ -115,9 +120,9 @@
def arg(self, val):
TYPE = lltype.typeOf(val)
_check_type(TYPE)
- if _fits_into_long(TYPE):
+ if _fits_into_signed(TYPE):
cls = IntArg
- val = rffi.cast(rffi.LONG, val)
+ val = rffi.cast(rffi.SIGNED, val)
elif TYPE is rffi.DOUBLE:
cls = FloatArg
elif TYPE is rffi.LONGLONG or TYPE is rffi.ULONGLONG:
@@ -250,7 +255,7 @@
if is_struct:
assert types.is_struct(self.restype)
res = self._do_call_raw(self.funcsym, ll_args)
- elif _fits_into_long(RESULT):
+ elif _fits_into_signed(RESULT):
assert not types.is_struct(self.restype)
res = self._do_call_int(self.funcsym, ll_args)
elif RESULT is rffi.DOUBLE:
@@ -309,7 +314,7 @@
@jit.oopspec('libffi_call_int(self, funcsym, ll_args)')
def _do_call_int(self, funcsym, ll_args):
- return self._do_call(funcsym, ll_args, rffi.LONG)
+ return self._do_call(funcsym, ll_args, rffi.SIGNED)
@jit.oopspec('libffi_call_float(self, funcsym, ll_args)')
def _do_call_float(self, funcsym, ll_args):
@@ -322,7 +327,7 @@
@jit.dont_look_inside
def _do_call_raw(self, funcsym, ll_args):
# same as _do_call_int, but marked as jit.dont_look_inside
- return self._do_call(funcsym, ll_args, rffi.LONG)
+ return self._do_call(funcsym, ll_args, rffi.SIGNED)
@jit.oopspec('libffi_call_longlong(self, funcsym, ll_args)')
def _do_call_longlong(self, funcsym, ll_args):
@@ -360,7 +365,7 @@
TP = lltype.Ptr(rffi.CArray(RESULT))
buf = rffi.cast(TP, ll_result)
if types.is_struct(self.restype):
- assert RESULT == rffi.LONG
+ assert RESULT == rffi.SIGNED
# for structs, we directly return the buffer and transfer the
# ownership
res = rffi.cast(RESULT, buf)
diff --git a/pypy/rlib/rmmap.py b/pypy/rlib/rmmap.py
--- a/pypy/rlib/rmmap.py
+++ b/pypy/rlib/rmmap.py
@@ -226,6 +226,7 @@
# XXX should be propagate the real type, allowing
# for 2*sys.maxint?
high = high_ref[0]
+ high = rffi.cast(lltype.Signed, high)
# low might just happen to have the value INVALID_FILE_SIZE
# so we need to check the last error also
INVALID_FILE_SIZE = -1
@@ -548,7 +549,7 @@
FILE_BEGIN = 0
high_ref = lltype.malloc(PLONG.TO, 1, flavor='raw')
try:
- high_ref[0] = newsize_high
+ high_ref[0] = rffi.cast(LONG, newsize_high)
SetFilePointer(self.file_handle, newsize_low, high_ref,
FILE_BEGIN)
finally:
@@ -710,7 +711,9 @@
free = c_munmap_safe
elif _MS_WINDOWS:
- def mmap(fileno, length, tagname="", access=_ACCESS_DEFAULT, offset=0):
+ def mmap(fileno, length, flags=0, tagname="", access=_ACCESS_DEFAULT, offset=0):
+ # XXX flags is or-ed into access by now.
+
# check size boundaries
_check_map_size(length)
map_size = length
@@ -792,6 +795,7 @@
offset_hi = 0
offset_lo = offset
+ flProtect |= flags
m.map_handle = CreateFileMapping(m.file_handle, NULL, flProtect,
size_hi, size_lo, m.tagname)
@@ -809,6 +813,11 @@
m.map_handle = INVALID_HANDLE
raise winerror
+ class Hint:
+ pos = -0x4fff0000 # for reproducible results
+ hint = Hint()
+ # XXX this has no effect on windows
+
def alloc(map_size):
"""Allocate memory. This is intended to be used by the JIT,
so the memory has the executable bit set.
diff --git a/pypy/rlib/test/test_libffi.py b/pypy/rlib/test/test_libffi.py
--- a/pypy/rlib/test/test_libffi.py
+++ b/pypy/rlib/test/test_libffi.py
@@ -34,8 +34,8 @@
# .arg() only supports integers and floats
chain = ArgChain()
x = lltype.malloc(lltype.GcStruct('xxx'))
- y = lltype.malloc(lltype.GcArray(rffi.LONG), 3)
- z = lltype.malloc(lltype.Array(rffi.LONG), 4, flavor='raw')
+ y = lltype.malloc(lltype.GcArray(rffi.SIGNED), 3)
+ z = lltype.malloc(lltype.Array(rffi.SIGNED), 4, flavor='raw')
py.test.raises(TypeError, "chain.arg(x)")
py.test.raises(TypeError, "chain.arg(y)")
py.test.raises(TypeError, "chain.arg(z)")
@@ -100,6 +100,7 @@
def setup_class(cls):
from pypy.tool.udir import udir
from pypy.translator.tool.cbuild import ExternalCompilationInfo
+ from pypy.translator.tool.cbuild import STANDARD_DEFINES
from pypy.translator.platform import platform
BaseFfiTest.setup_class()
@@ -120,7 +121,7 @@
for match in re.finditer(" ([a-z_]+)\(", meth.__doc__):
exports.append(match.group(1))
#
- c_file.write(py.code.Source('\n'.join(snippets)))
+ c_file.write(STANDARD_DEFINES + str(py.code.Source('\n'.join(snippets))))
eci = ExternalCompilationInfo(export_symbols=exports)
cls.libfoo_name = str(platform.compile([c_file], eci, 'x',
standalone=False))
@@ -157,13 +158,13 @@
def test_very_simple(self):
"""
- int diff_xy(int x, long y)
+ int diff_xy(int x, Signed y)
{
return x - y;
}
"""
libfoo = self.get_libfoo()
- func = (libfoo, 'diff_xy', [types.sint, types.slong], types.sint)
+ func = (libfoo, 'diff_xy', [types.sint, types.signed], types.sint)
res = self.call(func, [50, 8], lltype.Signed)
assert res == 42
@@ -206,7 +207,7 @@
"""
libfoo = self.get_libfoo()
func = (libfoo, 'many_args', [types.uchar, types.sint], types.sint)
- res = self.call(func, [chr(20), 22], rffi.LONG)
+ res = self.call(func, [chr(20), 22], rffi.SIGNED)
assert res == 42
def test_char_args(self):
@@ -235,9 +236,9 @@
def test_pointer_as_argument(self):
"""#include <stdlib.h>
- long inc(long* x)
+ Signed inc(Signed* x)
{
- long oldval;
+ Signed oldval;
if (x == NULL)
return -1;
oldval = *x;
@@ -246,15 +247,14 @@
}
"""
libfoo = self.get_libfoo()
- func = (libfoo, 'inc', [types.pointer], types.slong)
- LONGP = lltype.Ptr(rffi.CArray(rffi.LONG))
- null = lltype.nullptr(LONGP.TO)
- res = self.call(func, [null], rffi.LONG)
+ func = (libfoo, 'inc', [types.pointer], types.signed)
+ null = lltype.nullptr(rffi.SIGNEDP.TO)
+ res = self.call(func, [null], rffi.SIGNED)
assert res == -1
#
- ptr_result = lltype.malloc(LONGP.TO, 1, flavor='raw')
+ ptr_result = lltype.malloc(rffi.SIGNEDP.TO, 1, flavor='raw')
ptr_result[0] = 41
- res = self.call(func, [ptr_result], rffi.LONG)
+ res = self.call(func, [ptr_result], rffi.SIGNED)
if self.__class__ is TestLibffiCall:
# the function was called only once
assert res == 41
@@ -274,21 +274,20 @@
def test_return_pointer(self):
"""
struct pair {
- long a;
- long b;
+ Signed a;
+ Signed b;
};
struct pair my_static_pair = {10, 20};
- long* get_pointer_to_b()
+ Signed* get_pointer_to_b()
{
return &my_static_pair.b;
}
"""
libfoo = self.get_libfoo()
func = (libfoo, 'get_pointer_to_b', [], types.pointer)
- LONGP = lltype.Ptr(rffi.CArray(rffi.LONG))
- res = self.call(func, [], LONGP)
+ res = self.call(func, [], rffi.SIGNEDP)
assert res[0] == 20
def test_void_result(self):
@@ -301,12 +300,12 @@
set_dummy = (libfoo, 'set_dummy', [types.sint], types.void)
get_dummy = (libfoo, 'get_dummy', [], types.sint)
#
- initval = self.call(get_dummy, [], rffi.LONG)
+ initval = self.call(get_dummy, [], rffi.SIGNED)
#
res = self.call(set_dummy, [initval+1], lltype.Void)
assert res is None
#
- res = self.call(get_dummy, [], rffi.LONG)
+ res = self.call(get_dummy, [], rffi.SIGNED)
assert res == initval+1
def test_single_float_args(self):
@@ -386,32 +385,32 @@
else:
assert False, 'Did not raise'
- my_raises("self.call(func, [38], rffi.LONG)") # one less
- my_raises("self.call(func, [38, 12.3, 42], rffi.LONG)") # one more
+ my_raises("self.call(func, [38], rffi.SIGNED)") # one less
+ my_raises("self.call(func, [38, 12.3, 42], rffi.SIGNED)") # one more
def test_byval_argument(self):
"""
struct Point {
- long x;
- long y;
+ Signed x;
+ Signed y;
};
- long sum_point(struct Point p) {
+ Signed sum_point(struct Point p) {
return p.x + p.y;
}
"""
libfoo = CDLL(self.libfoo_name)
- ffi_point_struct = make_struct_ffitype_e(0, 0, [types.slong, types.slong])
+ ffi_point_struct = make_struct_ffitype_e(0, 0, [types.signed, types.signed])
ffi_point = ffi_point_struct.ffistruct
- sum_point = (libfoo, 'sum_point', [ffi_point], types.slong)
+ sum_point = (libfoo, 'sum_point', [ffi_point], types.signed)
#
- ARRAY = rffi.CArray(rffi.LONG)
+ ARRAY = rffi.CArray(rffi.SIGNED)
buf = lltype.malloc(ARRAY, 2, flavor='raw')
buf[0] = 30
buf[1] = 12
adr = rffi.cast(rffi.VOIDP, buf)
- res = self.call(sum_point, [('arg_raw', adr)], rffi.LONG,
+ res = self.call(sum_point, [('arg_raw', adr)], rffi.SIGNED,
jitif=["byval"])
assert res == 42
# check that we still have the ownership on the buffer
@@ -422,7 +421,7 @@
def test_byval_result(self):
"""
- struct Point make_point(long x, long y) {
+ struct Point make_point(Signed x, Signed y) {
struct Point p;
p.x = x;
p.y = y;
@@ -430,13 +429,13 @@
}
"""
libfoo = CDLL(self.libfoo_name)
- ffi_point_struct = make_struct_ffitype_e(0, 0, [types.slong, types.slong])
+ ffi_point_struct = make_struct_ffitype_e(0, 0, [types.signed, types.signed])
ffi_point = ffi_point_struct.ffistruct
libfoo = CDLL(self.libfoo_name)
- make_point = (libfoo, 'make_point', [types.slong, types.slong], ffi_point)
+ make_point = (libfoo, 'make_point', [types.signed, types.signed], ffi_point)
#
- PTR = lltype.Ptr(rffi.CArray(rffi.LONG))
+ PTR = lltype.Ptr(rffi.CArray(rffi.SIGNED))
p = self.call(make_point, [12, 34], PTR, is_struct=True,
jitif=["byval"])
assert p[0] == 12
diff --git a/pypy/rpython/lltypesystem/rffi.py b/pypy/rpython/lltypesystem/rffi.py
--- a/pypy/rpython/lltypesystem/rffi.py
+++ b/pypy/rpython/lltypesystem/rffi.py
@@ -18,6 +18,7 @@
from pypy.rlib.rstring import StringBuilder, UnicodeBuilder, assert_str0
from pypy.rlib import jit
from pypy.rpython.lltypesystem import llmemory
+from pypy.rlib.rarithmetic import maxint, LONG_BIT
import os, sys
class CConstant(Symbolic):
@@ -649,8 +650,9 @@
# float *
FLOATP = lltype.Ptr(lltype.Array(FLOAT, hints={'nolength': True}))
-# SIGNED *
-SIGNEDP = lltype.Ptr(lltype.Array(lltype.Signed, hints={'nolength': True}))
+# Signed, Signed *
+SIGNED = lltype.Signed
+SIGNEDP = lltype.Ptr(lltype.Array(SIGNED, hints={'nolength': True}))
# various type mapping
@@ -900,7 +902,7 @@
size = llmemory.sizeof(tp) # a symbolic result in this case
return size
if isinstance(tp, lltype.Ptr) or tp is llmemory.Address:
- tp = ULONG # XXX!
+ tp = lltype.Signed
if tp is lltype.Char or tp is lltype.Bool:
return 1
if tp is lltype.UniChar:
@@ -911,7 +913,7 @@
return 4
assert isinstance(tp, lltype.Number)
if tp is lltype.Signed:
- return ULONG._type.BITS/8
+ return LONG_BIT/8
return tp._type.BITS/8
sizeof._annspecialcase_ = 'specialize:memo'
@@ -931,11 +933,11 @@
offsetof._annspecialcase_ = 'specialize:memo'
# check that we have a sane configuration
-assert sys.maxint == (1 << (8 * sizeof(lltype.Signed) - 1)) - 1, (
+assert maxint == (1 << (8 * sizeof(lltype.Signed) - 1)) - 1, (
"Mixed configuration of the word size of the machine:\n\t"
"the underlying Python was compiled with maxint=%d,\n\t"
"but the C compiler says that 'long' is %d bytes" % (
- sys.maxint, sizeof(lltype.Signed)))
+ maxint, sizeof(lltype.Signed)))
# ********************** some helpers *******************
diff --git a/pypy/rpython/lltypesystem/test/test_rffi.py b/pypy/rpython/lltypesystem/test/test_rffi.py
--- a/pypy/rpython/lltypesystem/test/test_rffi.py
+++ b/pypy/rpython/lltypesystem/test/test_rffi.py
@@ -180,7 +180,7 @@
struct.c_three = cast(INT, 5)
result = z(struct)
lltype.free(struct, flavor='raw')
- return cast(LONG, result)
+ return cast(SIGNED, result)
fn = self.compile(f, [], backendopt=False)
assert fn() == 8
@@ -377,7 +377,7 @@
h_source = py.code.Source("""
#ifndef _CALLBACK_H
#define _CALLBACK_H
- extern long eating_callback(long arg, long(*call)(long));
+ extern Signed eating_callback(Signed arg, Signed(*call)(Signed));
#endif /* _CALLBACK_H */
""")
@@ -385,9 +385,9 @@
h_include.write(h_source)
c_source = py.code.Source("""
- long eating_callback(long arg, long(*call)(long))
+ Signed eating_callback(Signed arg, Signed(*call)(Signed))
{
- long res = call(arg);
+ Signed res = call(arg);
if (res == -1)
return -1;
return res;
@@ -399,8 +399,8 @@
separate_module_sources=[c_source],
export_symbols=['eating_callback'])
- args = [LONG, CCallback([LONG], LONG)]
- eating_callback = llexternal('eating_callback', args, LONG,
+ args = [SIGNED, CCallback([SIGNED], SIGNED)]
+ eating_callback = llexternal('eating_callback', args, SIGNED,
compilation_info=eci)
return eating_callback
@@ -554,13 +554,13 @@
p = make(X, c_one=cast(INT, 3))
res = p.c_one
lltype.free(p, flavor='raw')
- return cast(LONG, res)
+ return cast(SIGNED, res)
assert f() == 3
assert interpret(f, []) == 3
def test_structcopy(self):
- X2 = lltype.Struct('X2', ('x', LONG))
- X1 = lltype.Struct('X1', ('a', LONG), ('x2', X2), ('p', lltype.Ptr(X2)))
+ X2 = lltype.Struct('X2', ('x', SIGNED))
+ X1 = lltype.Struct('X1', ('a', SIGNED), ('x2', X2), ('p', lltype.Ptr(X2)))
def f():
p2 = make(X2, x=123)
p1 = make(X1, a=5, p=p2)
@@ -620,7 +620,7 @@
eci = ExternalCompilationInfo(includes=['string.h'])
strlen = llexternal('strlen', [CCHARP], SIZE_T, compilation_info=eci)
def f():
- return cast(LONG, strlen("Xxx"))
+ return cast(SIGNED, strlen("Xxx"))
assert interpret(f, [], backendopt=True) == 3
def test_stringpolicy3(self):
@@ -643,7 +643,7 @@
ll_str = str2charp("Xxx")
res2 = strlen(ll_str)
lltype.free(ll_str, flavor='raw')
- return cast(LONG, res1*10 + res2)
+ return cast(SIGNED, res1*10 + res2)
assert interpret(f, [], backendopt=True) == 43
diff --git a/pypy/rpython/module/ll_os.py b/pypy/rpython/module/ll_os.py
--- a/pypy/rpython/module/ll_os.py
+++ b/pypy/rpython/module/ll_os.py
@@ -237,7 +237,7 @@
def extdef_for_os_function_returning_int(self, name, **kwds):
c_func = self.llexternal(name, [], rffi.INT, **kwds)
def c_func_llimpl():
- res = rffi.cast(rffi.LONG, c_func())
+ res = rffi.cast(rffi.SIGNED, c_func())
if res == -1:
raise OSError(rposix.get_errno(), "%s failed" % name)
return res
@@ -249,7 +249,7 @@
def extdef_for_os_function_accepting_int(self, name, **kwds):
c_func = self.llexternal(name, [rffi.INT], rffi.INT, **kwds)
def c_func_llimpl(arg):
- res = rffi.cast(rffi.LONG, c_func(arg))
+ res = rffi.cast(rffi.SIGNED, c_func(arg))
if res == -1:
raise OSError(rposix.get_errno(), "%s failed" % name)
@@ -261,7 +261,7 @@
def extdef_for_os_function_accepting_2int(self, name, **kwds):
c_func = self.llexternal(name, [rffi.INT, rffi.INT], rffi.INT, **kwds)
def c_func_llimpl(arg, arg2):
- res = rffi.cast(rffi.LONG, c_func(arg, arg2))
+ res = rffi.cast(rffi.SIGNED, c_func(arg, arg2))
if res == -1:
raise OSError(rposix.get_errno(), "%s failed" % name)
@@ -273,7 +273,7 @@
def extdef_for_os_function_accepting_0int(self, name, **kwds):
c_func = self.llexternal(name, [], rffi.INT, **kwds)
def c_func_llimpl():
- res = rffi.cast(rffi.LONG, c_func())
+ res = rffi.cast(rffi.SIGNED, c_func())
if res == -1:
raise OSError(rposix.get_errno(), "%s failed" % name)
@@ -285,7 +285,7 @@
def extdef_for_os_function_int_to_int(self, name, **kwds):
c_func = self.llexternal(name, [rffi.INT], rffi.INT, **kwds)
def c_func_llimpl(arg):
- res = rffi.cast(rffi.LONG, c_func(arg))
+ res = rffi.cast(rffi.SIGNED, c_func(arg))
if res == -1:
raise OSError(rposix.get_errno(), "%s failed" % name)
return res
@@ -438,9 +438,13 @@
UTIMBUFP = lltype.Ptr(self.UTIMBUF)
os_utime = self.llexternal('utime', [rffi.CCHARP, UTIMBUFP], rffi.INT)
+ if not _WIN32:
+ includes = ['sys/time.h']
+ else:
+ includes = ['time.h']
class CConfig:
_compilation_info_ = ExternalCompilationInfo(
- includes=['sys/time.h']
+ includes=includes
)
HAVE_UTIMES = platform.Has('utimes')
config = platform.configure(CConfig)
@@ -450,9 +454,14 @@
if config['HAVE_UTIMES']:
class CConfig:
- _compilation_info_ = ExternalCompilationInfo(
- includes = ['sys/time.h']
- )
+ if not _WIN32:
+ _compilation_info_ = ExternalCompilationInfo(
+ includes = includes
+ )
+ else:
+ _compilation_info_ = ExternalCompilationInfo(
+ includes = ['time.h']
+ )
TIMEVAL = platform.Struct('struct timeval', [('tv_sec', rffi.LONG),
('tv_usec', rffi.LONG)])
config = platform.configure(CConfig)
@@ -557,10 +566,10 @@
# The fields of a FILETIME structure are the hi and lo parts
# of a 64-bit value expressed in 100 nanosecond units
# (of course).
- result = (pkernel.c_dwHighDateTime*429.4967296 +
- pkernel.c_dwLowDateTime*1E-7,
- puser.c_dwHighDateTime*429.4967296 +
- puser.c_dwLowDateTime*1E-7,
+ result = (rffi.cast(lltype.Signed, pkernel.c_dwHighDateTime) * 429.4967296 +
+ rffi.cast(lltype.Signed, pkernel.c_dwLowDateTime) * 1E-7,
+ rffi.cast(lltype.Signed, puser.c_dwHighDateTime) * 429.4967296 +
+ rffi.cast(lltype.Signed, puser.c_dwLowDateTime) * 1E-7,
0, 0, 0)
lltype.free(puser, flavor='raw')
lltype.free(pkernel, flavor='raw')
@@ -755,7 +764,7 @@
if self.GETPGRP_HAVE_ARG:
c_func = self.llexternal(name, [rffi.INT], rffi.INT)
def c_func_llimpl():
- res = rffi.cast(rffi.LONG, c_func(0))
+ res = rffi.cast(rffi.SIGNED, c_func(0))
if res == -1:
raise OSError(rposix.get_errno(), "%s failed" % name)
return res
@@ -773,7 +782,7 @@
if self.SETPGRP_HAVE_ARG:
c_func = self.llexternal(name, [rffi.INT, rffi.INT], rffi.INT)
def c_func_llimpl():
- res = rffi.cast(rffi.LONG, c_func(0, 0))
+ res = rffi.cast(rffi.SIGNED, c_func(0, 0))
if res == -1:
raise OSError(rposix.get_errno(), "%s failed" % name)
@@ -818,7 +827,7 @@
[traits.CCHARP, rffi.INT, rffi.MODE_T],
rffi.INT)
def os_open_llimpl(path, flags, mode):
- result = rffi.cast(rffi.LONG, os_open(path, flags, mode))
+ result = rffi.cast(lltype.Signed, os_open(path, flags, mode))
if result == -1:
raise OSError(rposix.get_errno(), "os_open failed")
return result
@@ -1009,7 +1018,7 @@
os_fsync = self.llexternal('_commit', [rffi.INT], rffi.INT)
def fsync_llimpl(fd):
- res = rffi.cast(rffi.LONG, os_fsync(rffi.cast(rffi.INT, fd)))
+ res = rffi.cast(rffi.SIGNED, os_fsync(rffi.cast(rffi.INT, fd)))
if res < 0:
raise OSError(rposix.get_errno(), "fsync failed")
return extdef([int], s_None,
@@ -1021,7 +1030,7 @@
os_fdatasync = self.llexternal('fdatasync', [rffi.INT], rffi.INT)
def fdatasync_llimpl(fd):
- res = rffi.cast(rffi.LONG, os_fdatasync(rffi.cast(rffi.INT, fd)))
+ res = rffi.cast(rffi.SIGNED, os_fdatasync(rffi.cast(rffi.INT, fd)))
if res < 0:
raise OSError(rposix.get_errno(), "fdatasync failed")
return extdef([int], s_None,
@@ -1033,7 +1042,7 @@
os_fchdir = self.llexternal('fchdir', [rffi.INT], rffi.INT)
def fchdir_llimpl(fd):
- res = rffi.cast(rffi.LONG, os_fchdir(rffi.cast(rffi.INT, fd)))
+ res = rffi.cast(rffi.SIGNED, os_fchdir(rffi.cast(rffi.INT, fd)))
if res < 0:
raise OSError(rposix.get_errno(), "fchdir failed")
return extdef([int], s_None,
@@ -1312,7 +1321,9 @@
result = os__cwait(status_p, pid, options)
# shift the status left a byte so this is more
# like the POSIX waitpid
- status_p[0] <<= 8
+ tmp = rffi.cast(rffi.SIGNED, status_p[0])
+ tmp <<= 8
+ status_p[0] = rffi.cast(rffi.INT, tmp)
return result
else:
# Posix
@@ -1343,7 +1354,7 @@
os_isatty = self.llexternal(underscore_on_windows+'isatty', [rffi.INT], rffi.INT)
def isatty_llimpl(fd):
- res = rffi.cast(rffi.LONG, os_isatty(rffi.cast(rffi.INT, fd)))
+ res = rffi.cast(lltype.Signed, os_isatty(rffi.cast(rffi.INT, fd)))
return res != 0
return extdef([int], bool, llimpl=isatty_llimpl,
diff --git a/pypy/rpython/module/ll_time.py b/pypy/rpython/module/ll_time.py
--- a/pypy/rpython/module/ll_time.py
+++ b/pypy/rpython/module/ll_time.py
@@ -9,7 +9,7 @@
from pypy.rpython.lltypesystem import lltype
from pypy.rpython.extfunc import BaseLazyRegistering, registering, extdef
from pypy.rlib import rposix
-from pypy.rlib.rarithmetic import intmask
+from pypy.rlib.rarithmetic import intmask, maxint32
from pypy.translator.tool.cbuild import ExternalCompilationInfo
if sys.platform == 'win32':
@@ -177,7 +177,7 @@
@registering(time.sleep)
def register_time_sleep(self):
if sys.platform == 'win32':
- MAX = sys.maxint
+ MAX = maxint32
Sleep = self.llexternal('Sleep', [rffi.ULONG], lltype.Void)
def time_sleep_llimpl(secs):
millisecs = secs * 1000.0
diff --git a/pypy/rpython/ootypesystem/ootype.py b/pypy/rpython/ootypesystem/ootype.py
--- a/pypy/rpython/ootypesystem/ootype.py
+++ b/pypy/rpython/ootypesystem/ootype.py
@@ -1295,6 +1295,8 @@
for meth in self.overloadings:
ARGS = meth._TYPE.ARGS
if ARGS in signatures:
+ # XXX Conflict on 'Signed' vs 'SignedLongLong' on win64.
+ # XXX note that this partially works if this error is ignored.
raise TypeError, 'Bad overloading'
signatures.add(ARGS)
diff --git a/pypy/rpython/test/test_rptr.py b/pypy/rpython/test/test_rptr.py
--- a/pypy/rpython/test/test_rptr.py
+++ b/pypy/rpython/test/test_rptr.py
@@ -5,6 +5,7 @@
from pypy.rpython.lltypesystem import llmemory
from pypy.rpython.rtyper import RPythonTyper
from pypy.annotation import model as annmodel
+from pypy.rlib.rarithmetic import is_valid_int
# ____________________________________________________________
@@ -188,7 +189,7 @@
return llmemory.cast_adr_to_int(a, "forced")
res = interpret(fn, [2])
- assert type(res) is int
+ assert is_valid_int(res)
assert res == cast_ptr_to_int(p)
#
res = interpret(fn, [4])
@@ -196,7 +197,7 @@
assert llmemory.cast_int_to_adr(res) == llmemory.cast_ptr_to_adr(p)
#
res = interpret(fn, [6])
- assert type(res) is int
+ assert is_valid_int(res)
from pypy.rpython.lltypesystem import rffi
assert res == rffi.cast(Signed, p)
diff --git a/pypy/rpython/tool/rffi_platform.py b/pypy/rpython/tool/rffi_platform.py
--- a/pypy/rpython/tool/rffi_platform.py
+++ b/pypy/rpython/tool/rffi_platform.py
@@ -710,9 +710,13 @@
PYPY_EXTERNAL_DIR = py.path.local(pypydir).join('..', '..')
# XXX make this configurable
if sys.platform == 'win32':
- libdir = py.path.local('c:/buildslave/support') # on the bigboard buildbot
- if libdir.check():
- PYPY_EXTERNAL_DIR = libdir
+ for libdir in [
+ py.path.local('c:/buildslave/support'), # on the bigboard buildbot
+ py.path.local('d:/myslave'), # on the snakepit buildbot
+ ]:
+ if libdir.check():
+ PYPY_EXTERNAL_DIR = libdir
+ break
def configure_external_library(name, eci, configurations,
symbol=None, _cache={}):
@@ -790,9 +794,15 @@
if platform is None:
from pypy.translator.platform import platform
if sys.platform == 'win32':
- library_dir = 'Release'
- libraries = ['gc']
- includes=['gc.h']
+ import platform as host_platform # just to ask for the arch. Confusion-alert!
+ if host_platform.architecture()[0] == '32bit':
+ library_dir = 'Release'
+ libraries = ['gc']
+ includes=['gc.h']
+ else:
+ library_dir = ''
+ libraries = ['gc64_dll']
+ includes = ['gc.h']
else:
library_dir = ''
libraries = ['gc', 'dl']
diff --git a/pypy/translator/cli/sdk.py b/pypy/translator/cli/sdk.py
--- a/pypy/translator/cli/sdk.py
+++ b/pypy/translator/cli/sdk.py
@@ -103,6 +103,11 @@
mono_bin = find_mono_on_windows()
if mono_bin is not None:
SDK.ILASM = os.path.join(mono_bin, 'ilasm2.bat')
+ # XXX the failing tests are boring, and the SDK is usually installed
+ # on windows. I do not care right now, because the Linux buildbots
+ # don't test this at all...
+ if platform.architecture()[0] == '64bit':
+ py.test.skip('mono on 64bit is not well enough supported')
else:
SDK = MonoSDK
return SDK
diff --git a/pytest.py b/pytest.py
--- a/pytest.py
+++ b/pytest.py
@@ -4,6 +4,20 @@
"""
__all__ = ['main']
+# XXX hack for win64:
+# This patch must stay here until the END OF STAGE 1
+# When all tests work, this branch will be merged
+# and the branch stage 2 is started, where we remove this patch.
+import sys
+if hasattr(sys, "maxsize"):
+ if sys.maxint != sys.maxsize:
+ sys.maxint = sys.maxsize
+ import warnings
+ warnings.warn("""\n
+---> This win64 port is now in stage 1: sys.maxint was modified.
+---> When pypy/__init__.py becomes empty again, we have reached stage 2.
+""")
+
from _pytest.core import main, UsageError, _preloadplugins
from _pytest import core as cmdline
from _pytest import __version__
More information about the pypy-commit
mailing list