[pypy-commit] pypy fastjson: hg merge default
antocuni
noreply at buildbot.pypy.org
Mon Jul 8 11:20:16 CEST 2013
Author: Antonio Cuni <anto.cuni at gmail.com>
Branch: fastjson
Changeset: r65261:344ca3721bd5
Date: 2013-07-08 11:17 +0200
http://bitbucket.org/pypy/pypy/changeset/344ca3721bd5/
Log: hg merge default
diff too long, truncating to 2000 out of 4574 lines
diff --git a/.hgignore b/.hgignore
--- a/.hgignore
+++ b/.hgignore
@@ -6,6 +6,7 @@
.idea
.project
.pydevproject
+__pycache__
syntax: regexp
^testresult$
diff --git a/lib_pypy/ctypes_config_cache/syslog.ctc.py b/lib_pypy/ctypes_config_cache/syslog.ctc.py
deleted file mode 100644
--- a/lib_pypy/ctypes_config_cache/syslog.ctc.py
+++ /dev/null
@@ -1,75 +0,0 @@
-"""
-'ctypes_configure' source for syslog.py.
-Run this to rebuild _syslog_cache.py.
-"""
-
-from ctypes_configure.configure import (configure,
- ExternalCompilationInfo, ConstantInteger, DefinedConstantInteger)
-import dumpcache
-
-
-_CONSTANTS = (
- 'LOG_EMERG',
- 'LOG_ALERT',
- 'LOG_CRIT',
- 'LOG_ERR',
- 'LOG_WARNING',
- 'LOG_NOTICE',
- 'LOG_INFO',
- 'LOG_DEBUG',
-
- 'LOG_PID',
- 'LOG_CONS',
- 'LOG_NDELAY',
-
- 'LOG_KERN',
- 'LOG_USER',
- 'LOG_MAIL',
- 'LOG_DAEMON',
- 'LOG_AUTH',
- 'LOG_LPR',
- 'LOG_LOCAL0',
- 'LOG_LOCAL1',
- 'LOG_LOCAL2',
- 'LOG_LOCAL3',
- 'LOG_LOCAL4',
- 'LOG_LOCAL5',
- 'LOG_LOCAL6',
- 'LOG_LOCAL7',
-)
-_OPTIONAL_CONSTANTS = (
- 'LOG_NOWAIT',
- 'LOG_PERROR',
-
- 'LOG_SYSLOG',
- 'LOG_CRON',
- 'LOG_UUCP',
- 'LOG_NEWS',
-)
-
-# Constant aliases if there are not defined
-_ALIAS = (
- ('LOG_SYSLOG', 'LOG_DAEMON'),
- ('LOG_CRON', 'LOG_DAEMON'),
- ('LOG_NEWS', 'LOG_MAIL'),
- ('LOG_UUCP', 'LOG_MAIL'),
-)
-
-class SyslogConfigure:
- _compilation_info_ = ExternalCompilationInfo(includes=['sys/syslog.h'])
-for key in _CONSTANTS:
- setattr(SyslogConfigure, key, ConstantInteger(key))
-for key in _OPTIONAL_CONSTANTS:
- setattr(SyslogConfigure, key, DefinedConstantInteger(key))
-
-config = configure(SyslogConfigure)
-for key in _OPTIONAL_CONSTANTS:
- if config[key] is None:
- del config[key]
-for alias, key in _ALIAS:
- config.setdefault(alias, config[key])
-
-all_constants = config.keys()
-all_constants.sort()
-config['ALL_CONSTANTS'] = tuple(all_constants)
-dumpcache.dumpcache2('syslog', config)
diff --git a/lib_pypy/greenlet.py b/lib_pypy/greenlet.py
--- a/lib_pypy/greenlet.py
+++ b/lib_pypy/greenlet.py
@@ -46,16 +46,16 @@
if parent is not None:
self.parent = parent
- def switch(self, *args):
+ def switch(self, *args, **kwds):
"Switch execution to this greenlet, optionally passing the values "
"given as argument(s). Returns the value passed when switching back."
- return self.__switch('switch', args)
+ return self.__switch('switch', (args, kwds))
def throw(self, typ=GreenletExit, val=None, tb=None):
"raise exception in greenlet, return value passed when switching back"
return self.__switch('throw', typ, val, tb)
- def __switch(target, methodname, *args):
+ def __switch(target, methodname, *baseargs):
current = getcurrent()
#
while not (target.__main or _continulet.is_pending(target)):
@@ -65,9 +65,9 @@
greenlet_func = _greenlet_start
else:
greenlet_func = _greenlet_throw
- _continulet.__init__(target, greenlet_func, *args)
+ _continulet.__init__(target, greenlet_func, *baseargs)
methodname = 'switch'
- args = ()
+ baseargs = ()
target.__started = True
break
# already done, go to the parent instead
@@ -78,11 +78,15 @@
#
try:
unbound_method = getattr(_continulet, methodname)
- args = unbound_method(current, *args, to=target)
+ args, kwds = unbound_method(current, *baseargs, to=target)
finally:
_tls.current = current
#
- if len(args) == 1:
+ if kwds:
+ if args:
+ return args, kwds
+ return kwds
+ elif len(args) == 1:
return args[0]
else:
return args
@@ -129,14 +133,15 @@
_tls.current = gmain
def _greenlet_start(greenlet, args):
+ args, kwds = args
_tls.current = greenlet
try:
- res = greenlet.run(*args)
+ res = greenlet.run(*args, **kwds)
except GreenletExit, e:
res = e
finally:
_continuation.permute(greenlet, greenlet.parent)
- return (res,)
+ return ((res,), None)
def _greenlet_throw(greenlet, exc, value, tb):
_tls.current = greenlet
diff --git a/lib_pypy/grp.py b/lib_pypy/grp.py
--- a/lib_pypy/grp.py
+++ b/lib_pypy/grp.py
@@ -8,6 +8,7 @@
from ctypes import Structure, c_char_p, c_int, POINTER
from ctypes_support import standard_c_lib as libc
+import _structseq
try: from __pypy__ import builtinify
except ImportError: builtinify = lambda f: f
@@ -23,32 +24,13 @@
('gr_mem', POINTER(c_char_p)),
)
-class Group(object):
- def __init__(self, gr_name, gr_passwd, gr_gid, gr_mem):
- self.gr_name = gr_name
- self.gr_passwd = gr_passwd
- self.gr_gid = gr_gid
- self.gr_mem = gr_mem
+class struct_group:
+ __metaclass__ = _structseq.structseqtype
- def __getitem__(self, item):
- if item == 0:
- return self.gr_name
- elif item == 1:
- return self.gr_passwd
- elif item == 2:
- return self.gr_gid
- elif item == 3:
- return self.gr_mem
- else:
- raise IndexError(item)
-
- def __len__(self):
- return 4
-
- def __repr__(self):
- return str((self.gr_name, self.gr_passwd, self.gr_gid, self.gr_mem))
-
- # whatever else...
+ gr_name = _structseq.structseqfield(0)
+ gr_passwd = _structseq.structseqfield(1)
+ gr_gid = _structseq.structseqfield(2)
+ gr_mem = _structseq.structseqfield(3)
libc.getgrgid.argtypes = [gid_t]
libc.getgrgid.restype = POINTER(GroupStruct)
@@ -71,8 +53,8 @@
while res.contents.gr_mem[i]:
mem.append(res.contents.gr_mem[i])
i += 1
- return Group(res.contents.gr_name, res.contents.gr_passwd,
- res.contents.gr_gid, mem)
+ return struct_group((res.contents.gr_name, res.contents.gr_passwd,
+ res.contents.gr_gid, mem))
@builtinify
def getgrgid(gid):
diff --git a/lib_pypy/pyrepl/curses.py b/lib_pypy/pyrepl/curses.py
--- a/lib_pypy/pyrepl/curses.py
+++ b/lib_pypy/pyrepl/curses.py
@@ -19,11 +19,15 @@
# CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-# avoid importing the whole curses, if possible
-try:
+# If we are running on top of pypy, we import only _minimal_curses.
+# Don't try to fall back to _curses, because that's going to use cffi
+# and fall again more loudly.
+import sys
+if '__pypy__' in sys.builtin_module_names:
# pypy case
import _minimal_curses as _curses
-except ImportError:
+else:
+ # cpython case
try:
import _curses
except ImportError:
diff --git a/lib_pypy/syslog.py b/lib_pypy/syslog.py
--- a/lib_pypy/syslog.py
+++ b/lib_pypy/syslog.py
@@ -1,3 +1,4 @@
+# this cffi version was rewritten based on the
# ctypes implementation: Victor Stinner, 2008-05-08
"""
This module provides an interface to the Unix syslog library routines.
@@ -9,34 +10,84 @@
if sys.platform == 'win32':
raise ImportError("No syslog on Windows")
-# load the platform-specific cache made by running syslog.ctc.py
-from ctypes_config_cache._syslog_cache import *
-
-from ctypes_support import standard_c_lib as libc
-from ctypes import c_int, c_char_p
+from cffi import FFI
try: from __pypy__ import builtinify
except ImportError: builtinify = lambda f: f
+ffi = FFI()
-# Real prototype is:
-# void syslog(int priority, const char *format, ...);
-# But we also need format ("%s") and one format argument (message)
-_syslog = libc.syslog
-_syslog.argtypes = (c_int, c_char_p, c_char_p)
-_syslog.restype = None
+ffi.cdef("""
+/* mandatory constants */
+#define LOG_EMERG ...
+#define LOG_ALERT ...
+#define LOG_CRIT ...
+#define LOG_ERR ...
+#define LOG_WARNING ...
+#define LOG_NOTICE ...
+#define LOG_INFO ...
+#define LOG_DEBUG ...
-_openlog = libc.openlog
-_openlog.argtypes = (c_char_p, c_int, c_int)
-_openlog.restype = None
+#define LOG_PID ...
+#define LOG_CONS ...
+#define LOG_NDELAY ...
-_closelog = libc.closelog
-_closelog.argtypes = None
-_closelog.restype = None
+#define LOG_KERN ...
+#define LOG_USER ...
+#define LOG_MAIL ...
+#define LOG_DAEMON ...
+#define LOG_AUTH ...
+#define LOG_LPR ...
+#define LOG_LOCAL0 ...
+#define LOG_LOCAL1 ...
+#define LOG_LOCAL2 ...
+#define LOG_LOCAL3 ...
+#define LOG_LOCAL4 ...
+#define LOG_LOCAL5 ...
+#define LOG_LOCAL6 ...
+#define LOG_LOCAL7 ...
-_setlogmask = libc.setlogmask
-_setlogmask.argtypes = (c_int,)
-_setlogmask.restype = c_int
+/* optional constants, gets defined to -919919 if missing */
+#define LOG_NOWAIT ...
+#define LOG_PERROR ...
+
+/* aliased constants, gets defined as some other constant if missing */
+#define LOG_SYSLOG ...
+#define LOG_CRON ...
+#define LOG_UUCP ...
+#define LOG_NEWS ...
+
+/* functions */
+void openlog(const char *ident, int option, int facility);
+void syslog(int priority, const char *format, const char *string);
+// NB. the signature of syslog() is specialized to the only case we use
+void closelog(void);
+int setlogmask(int mask);
+""")
+
+lib = ffi.verify("""
+#include <syslog.h>
+
+#ifndef LOG_NOWAIT
+#define LOG_NOWAIT -919919
+#endif
+#ifndef LOG_PERROR
+#define LOG_PERROR -919919
+#endif
+#ifndef LOG_SYSLOG
+#define LOG_SYSLOG LOG_DAEMON
+#endif
+#ifndef LOG_CRON
+#define LOG_CRON LOG_DAEMON
+#endif
+#ifndef LOG_UUCP
+#define LOG_UUCP LOG_MAIL
+#endif
+#ifndef LOG_NEWS
+#define LOG_NEWS LOG_MAIL
+#endif
+""")
+
_S_log_open = False
_S_ident_o = None
@@ -52,12 +103,17 @@
return None
@builtinify
-def openlog(ident=None, logoption=0, facility=LOG_USER):
+def openlog(ident=None, logoption=0, facility=lib.LOG_USER):
global _S_ident_o, _S_log_open
if ident is None:
ident = _get_argv()
- _S_ident_o = c_char_p(ident) # keepalive
- _openlog(_S_ident_o, logoption, facility)
+ if ident is None:
+ _S_ident_o = ffi.NULL
+ elif isinstance(ident, str):
+ _S_ident_o = ffi.new("char[]", ident) # keepalive
+ else:
+ raise TypeError("'ident' must be a string or None")
+ lib.openlog(_S_ident_o, logoption, facility)
_S_log_open = True
@builtinify
@@ -69,19 +125,19 @@
# if log is not opened, open it now
if not _S_log_open:
openlog()
- _syslog(priority, "%s", message)
+ lib.syslog(priority, "%s", message)
@builtinify
def closelog():
global _S_log_open, S_ident_o
if _S_log_open:
- _closelog()
+ lib.closelog()
_S_log_open = False
_S_ident_o = None
@builtinify
def setlogmask(mask):
- return _setlogmask(mask)
+ return lib.setlogmask(mask)
@builtinify
def LOG_MASK(pri):
@@ -91,8 +147,15 @@
def LOG_UPTO(pri):
return (1 << (pri + 1)) - 1
-__all__ = ALL_CONSTANTS + (
+__all__ = []
+
+for name in sorted(lib.__dict__):
+ if name.startswith('LOG_'):
+ value = getattr(lib, name)
+ if value != -919919:
+ globals()[name] = value
+ __all__.append(name)
+
+__all__ = tuple(__all__) + (
'openlog', 'syslog', 'closelog', 'setlogmask',
'LOG_MASK', 'LOG_UPTO')
-
-del ALL_CONSTANTS
diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py
--- a/pypy/config/pypyoption.py
+++ b/pypy/config/pypyoption.py
@@ -144,7 +144,7 @@
requires=module_dependencies.get(modname, []),
suggests=module_suggests.get(modname, []),
negation=modname not in essential_modules,
- validator=get_module_validator(modname))
+ ) #validator=get_module_validator(modname))
for modname in all_modules]),
BoolOption("allworkingmodules", "use as many working modules as possible",
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
@@ -907,7 +907,7 @@
runs at application level. If you need to use modules
you have to import them within the test function.
-Another possibility to pass in data into the AppTest is to use
+Data can be passed into the AppTest using
the ``setup_class`` method of the AppTest. All wrapped objects that are
attached to the class there and start with ``w_`` can be accessed
via self (but without the ``w_``) in the actual test method. An example::
@@ -922,6 +922,46 @@
.. _`run the tests as usual`:
+Another possibility is to use cls.space.appexec, for example::
+
+ class AppTestSomething(object):
+ def setup_class(cls):
+ arg = 2
+ cls.w_result = cls.space.appexec([cls.space.wrap(arg)], """(arg):
+ return arg ** 6
+ """)
+
+ def test_power(self):
+ assert self.result == 2 ** 6
+
+which executes the code string function with the given arguments at app level.
+Note the use of ``w_result`` in ``setup_class`` but self.result in the test
+Here is how to define an app level class in ``setup_class`` that can be used
+in subsequent tests::
+
+ class AppTestSet(object):
+ def setup_class(cls):
+ w_fakeint = cls.space.appexec([], """():
+ class FakeInt(object):
+ def __init__(self, value):
+ self.value = value
+ def __hash__(self):
+ return hash(self.value)
+
+ def __eq__(self, other):
+ if other == self.value:
+ return True
+ return False
+ return FakeInt
+ """)
+ cls.w_FakeInt = w_fakeint
+
+ def test_fakeint(self):
+ f1 = self.FakeInt(4)
+ assert f1 == 4
+ assert hash(f1) == hash(4)
+
+
Command line tool test_all
--------------------------
diff --git a/pypy/doc/faq.rst b/pypy/doc/faq.rst
--- a/pypy/doc/faq.rst
+++ b/pypy/doc/faq.rst
@@ -96,8 +96,21 @@
Does PyPy have a GIL? Why?
-------------------------------------------------
-Yes, PyPy has a GIL. Removing the GIL is very hard. The first problem
-is that our garbage collectors are not re-entrant.
+Yes, PyPy has a GIL. Removing the GIL is very hard. The problems are
+essentially the same as with CPython (including the fact that our
+garbage collectors are not thread-safe so far). Fixing it is possible,
+as shown by Jython and IronPython, but difficult. It would require
+adapting the whole source code of PyPy, including subtle decisions about
+whether some effects are ok or not for the user (i.e. the Python
+programmer).
+
+Instead, since 2012, there is work going on on a still very experimental
+Software Transactional Memory (STM) version of PyPy. This should give
+an alternative PyPy which internally has no GIL, while at the same time
+continuing to give the Python programmer the complete illusion of having
+one. It would in fact push forward *more* GIL-ish behavior, like
+declaring that some sections of the code should run without releasing
+the GIL in the middle (these are called *atomic sections* in STM).
------------------------------------------
How do I write extension modules for PyPy?
@@ -306,7 +319,7 @@
No, and you shouldn't try. First and foremost, RPython is a language
designed for writing interpreters. It is a restricted subset of
-Python. If you program is not an interpreter but tries to do "real
+Python. If your program is not an interpreter but tries to do "real
things", like use *any* part of the standard Python library or *any*
3rd-party library, then it is not RPython to start with. You should
only look at RPython if you try to `write your own interpreter`__.
@@ -322,8 +335,35 @@
Yes, it is possible with enough effort to compile small self-contained
pieces of RPython code doing a few performance-sensitive things. But
this case is not interesting for us. If you needed to rewrite the code
-in RPython, you could as well have rewritten it in C for example. The
-latter is a much more supported, much more documented language `:-)`
+in RPython, you could as well have rewritten it in C or C++ or Java for
+example. These are much more supported, much more documented languages
+`:-)`
+
+ *The above paragraphs are not the whole truth. It* is *true that there
+ are cases where writing a program as RPython gives you substantially
+ better speed than running it on top of PyPy. However, the attitude of
+ the core group of people behind PyPy is to answer: "then report it as a
+ performance bug against PyPy!".*
+
+ *Here is a more diluted way to put it. The "No, don't!" above is a
+ general warning we give to new people. They are likely to need a lot
+ of help from* some *source, because RPython is not so simple nor
+ extensively documented; but at the same time, we, the pypy core group
+ of people, are not willing to invest time in supporting 3rd-party
+ projects that do very different things than interpreters for dynamic
+ languages --- just because we have other interests and there are only
+ so many hours a day. So as a summary I believe it is only fair to
+ attempt to point newcomers at existing alternatives, which are more
+ mainstream and where they will get help from many people.*
+
+ *If anybody seriously wants to promote RPython anyway, he is welcome
+ to: we won't actively resist such a plan. There are a lot of things
+ that could be done to make RPython a better Java-ish language for
+ example, starting with supporting non-GIL-based multithreading, but we
+ don't implement them because they have little relevance to us. This
+ is open source, which means that anybody is free to promote and
+ develop anything; but it also means that you must let us choose* not
+ *to go into that direction ourselves.*
---------------------------------------------------
Which backends are there for the RPython toolchain?
diff --git a/pypy/doc/how-to-contribute.rst b/pypy/doc/how-to-contribute.rst
--- a/pypy/doc/how-to-contribute.rst
+++ b/pypy/doc/how-to-contribute.rst
@@ -77,3 +77,4 @@
entry point.
.. _`introduction to RPython`: getting-started-dev.html
+.. _`pytest`: http://pytest.org/
diff --git a/pypy/doc/whatsnew-2.1.rst b/pypy/doc/whatsnew-2.1.rst
new file mode 100644
--- /dev/null
+++ b/pypy/doc/whatsnew-2.1.rst
@@ -0,0 +1,78 @@
+======================
+What's new in PyPy 2.1
+======================
+
+.. this is a revision shortly after release-2.0
+.. startrev: a13c07067613
+
+.. branch: ndarray-ptp
+put and array.put
+
+.. branch: numpy-pickle
+Pickling of numpy arrays and dtypes (including record dtypes)
+
+.. branch: remove-array-smm
+Remove multimethods in the arraymodule
+
+.. branch: callback-stacklet
+Fixed bug when switching stacklets from a C callback
+
+.. branch: remove-set-smm
+Remove multi-methods on sets
+
+.. branch: numpy-subarrays
+Implement subarrays for numpy
+
+.. branch: remove-dict-smm
+Remove multi-methods on dict
+
+.. branch: remove-list-smm-2
+Remove remaining multi-methods on list
+
+.. branch: arm-stacklet
+Stacklet support for ARM, enables _continuation support
+
+.. branch: remove-tuple-smm
+Remove multi-methods on tuple
+
+.. branch: remove-iter-smm
+Remove multi-methods on iterators
+
+.. branch: emit-call-x86
+.. branch: emit-call-arm
+
+.. branch: on-abort-resops
+Added list of resops to the pypyjit on_abort hook.
+
+.. branch: logging-perf
+Speeds up the stdlib logging module
+
+.. branch: operrfmt-NT
+Adds a couple convenient format specifiers to operationerrfmt
+
+.. branch: win32-fixes3
+Skip and fix some non-translated (own) tests for win32 builds
+
+.. branch: ctypes-byref
+Add the '_obj' attribute on ctypes pointer() and byref() objects
+
+.. branch: argsort-segfault
+Fix a segfault in argsort when sorting by chunks on multidim numpypy arrays (mikefc)
+
+.. branch: dtype-isnative
+.. branch: ndarray-round
+
+.. branch: faster-str-of-bigint
+Improve performance of str(long).
+
+.. branch: ndarray-view
+Add view to ndarray and zeroD arrays, not on dtype scalars yet
+
+.. branch: numpypy-segfault
+fix segfault caused by iterating over empty ndarrays
+
+.. branch: identity-set
+Faster sets for objects
+
+.. branch: inline-identityhash
+Inline the fast path of id() and hash()
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
@@ -5,6 +5,9 @@
.. this is a revision shortly after release-2.0
.. startrev: a13c07067613
+.. branch: ndarray-ptp
+put and array.put
+
.. branch: numpy-pickle
Pickling of numpy arrays and dtypes (including record dtypes)
@@ -57,3 +60,19 @@
Fix a segfault in argsort when sorting by chunks on multidim numpypy arrays (mikefc)
.. branch: dtype-isnative
+.. branch: ndarray-round
+
+.. branch: faster-str-of-bigint
+Improve performance of str(long).
+
+.. branch: ndarray-view
+Add view to ndarray and zeroD arrays, not on dtype scalars yet
+
+.. branch: numpypy-segfault
+fix segfault caused by iterating over empty ndarrays
+
+.. branch: identity-set
+Faster sets for objects
+
+.. branch: inline-identityhash
+Inline the fast path of id() and hash()
diff --git a/pypy/interpreter/error.py b/pypy/interpreter/error.py
--- a/pypy/interpreter/error.py
+++ b/pypy/interpreter/error.py
@@ -29,12 +29,12 @@
_application_traceback = None
def __init__(self, w_type, w_value, tb=None):
- assert w_type is not None
self.setup(w_type)
self._w_value = w_value
self._application_traceback = tb
def setup(self, w_type):
+ assert w_type is not None
self.w_type = w_type
if not we_are_translated():
self.debug_excs = []
@@ -347,7 +347,6 @@
self.xstrings = strings
for i, _, attr in entries:
setattr(self, attr, args[i])
- assert w_type is not None
def _compute_value(self, space):
lst = [None] * (len(formats) + len(formats) + 1)
@@ -369,6 +368,18 @@
_fmtcache2[formats] = OpErrFmt
return OpErrFmt, strings
+class OpErrFmtNoArgs(OperationError):
+
+ def __init__(self, w_type, value):
+ self.setup(w_type)
+ self._value = value
+
+ def get_w_value(self, space):
+ w_value = self._w_value
+ if w_value is None:
+ self._w_value = w_value = space.wrap(self._value)
+ return w_value
+
def get_operationerr_class(valuefmt):
try:
result = _fmtcache[valuefmt]
@@ -389,6 +400,8 @@
%T - The result of space.type(w_arg).getname(space)
"""
+ if not len(args):
+ return OpErrFmtNoArgs(w_type, valuefmt)
OpErrFmt, strings = get_operationerr_class(valuefmt)
return OpErrFmt(w_type, strings, *args)
operationerrfmt._annspecialcase_ = 'specialize:arg(1)'
diff --git a/pypy/interpreter/test/test_error.py b/pypy/interpreter/test/test_error.py
--- a/pypy/interpreter/test/test_error.py
+++ b/pypy/interpreter/test/test_error.py
@@ -33,6 +33,14 @@
operr3 = operationerrfmt("w_type2", "a %s b %s c", "bar", "4b")
assert operr3.__class__ is not operr.__class__
+def test_operationerrfmt_noargs(space):
+ operr = operationerrfmt(space.w_AttributeError, "no attribute 'foo'")
+ operr.normalize_exception(space)
+ val = operr.get_w_value(space)
+ assert space.isinstance_w(val, space.w_AttributeError)
+ w_repr = space.repr(val)
+ assert space.str_w(w_repr) == "AttributeError(\"no attribute 'foo'\",)"
+
def test_operationerrfmt_T(space):
operr = operationerrfmt(space.w_AttributeError,
"'%T' object has no attribute '%s'",
diff --git a/pypy/module/_csv/interp_reader.py b/pypy/module/_csv/interp_reader.py
--- a/pypy/module/_csv/interp_reader.py
+++ b/pypy/module/_csv/interp_reader.py
@@ -41,8 +41,8 @@
def save_field(self, field_builder):
field = field_builder.build()
if self.numeric_field:
- from pypy.objspace.std.strutil import ParseStringError
- from pypy.objspace.std.strutil import string_to_float
+ from rpython.rlib.rstring import ParseStringError
+ from rpython.rlib.rfloat import string_to_float
self.numeric_field = False
try:
ff = string_to_float(field)
diff --git a/pypy/module/_io/interp_iobase.py b/pypy/module/_io/interp_iobase.py
--- a/pypy/module/_io/interp_iobase.py
+++ b/pypy/module/_io/interp_iobase.py
@@ -101,6 +101,9 @@
raise OperationError(
space.w_ValueError, space.wrap(message))
+ def check_closed_w(self, space):
+ self._check_closed(space)
+
def closed_get_w(self, space):
return space.newbool(self.__IOBase_closed)
@@ -277,6 +280,7 @@
_checkReadable = interp2app(check_readable_w),
_checkWritable = interp2app(check_writable_w),
_checkSeekable = interp2app(check_seekable_w),
+ _checkClosed = interp2app(W_IOBase.check_closed_w),
closed = GetSetProperty(W_IOBase.closed_get_w),
__dict__ = GetSetProperty(descr_get_dict, descr_set_dict, cls=W_IOBase),
__weakref__ = make_weakref_descr(W_IOBase),
diff --git a/pypy/module/_io/test/test_io.py b/pypy/module/_io/test/test_io.py
--- a/pypy/module/_io/test/test_io.py
+++ b/pypy/module/_io/test/test_io.py
@@ -22,7 +22,9 @@
import io
with io.BufferedIOBase() as f:
assert not f.closed
+ f._checkClosed()
assert f.closed
+ raises(ValueError, f._checkClosed)
def test_iter(self):
import io
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
@@ -71,6 +71,7 @@
'complex_': 'interp_boxes.W_Complex128Box',
'complex128': 'interp_boxes.W_Complex128Box',
'complex64': 'interp_boxes.W_Complex64Box',
+ 'cfloat': 'interp_boxes.W_Complex64Box',
}
if ENABLED_LONG_DOUBLE:
long_double_dtypes = [
@@ -183,6 +184,7 @@
appleveldefs = {}
interpleveldefs = {
'choose': 'interp_arrayops.choose',
+ 'put': 'interp_arrayops.put',
'repeat': 'interp_arrayops.repeat',
}
submodules = {
diff --git a/pypy/module/micronumpy/arrayimpl/concrete.py b/pypy/module/micronumpy/arrayimpl/concrete.py
--- a/pypy/module/micronumpy/arrayimpl/concrete.py
+++ b/pypy/module/micronumpy/arrayimpl/concrete.py
@@ -75,6 +75,12 @@
else:
return None
+ def get_view(self, orig_array, dtype, new_shape):
+ strides, backstrides = support.calc_strides(new_shape, dtype,
+ self.order)
+ return SliceArray(self.start, strides, backstrides, new_shape,
+ self, orig_array, dtype=dtype)
+
def get_real(self, orig_array):
strides = self.get_strides()
backstrides = self.get_backstrides()
diff --git a/pypy/module/micronumpy/arrayimpl/scalar.py b/pypy/module/micronumpy/arrayimpl/scalar.py
--- a/pypy/module/micronumpy/arrayimpl/scalar.py
+++ b/pypy/module/micronumpy/arrayimpl/scalar.py
@@ -13,6 +13,9 @@
def next(self):
self.called_once = True
+ def next_skip_x(self, n):
+ self.called_once = True
+
def getitem(self):
return self.v.get_scalar_value()
@@ -63,6 +66,11 @@
def transpose(self, _):
return self
+ def get_view(self, orig_array, dtype, new_shape):
+ scalar = Scalar(dtype)
+ scalar.value = self.value.convert_to(dtype)
+ return scalar
+
def get_real(self, orig_array):
if self.dtype.is_complex_type():
scalar = Scalar(self.dtype.float_type)
diff --git a/pypy/module/micronumpy/compile.py b/pypy/module/micronumpy/compile.py
--- a/pypy/module/micronumpy/compile.py
+++ b/pypy/module/micronumpy/compile.py
@@ -51,6 +51,7 @@
w_IndexError = W_TypeObject("IndexError")
w_OverflowError = W_TypeObject("OverflowError")
w_NotImplementedError = W_TypeObject("NotImplementedError")
+ w_AttributeError = W_TypeObject("AttributeError")
w_None = None
w_bool = W_TypeObject("bool")
diff --git a/pypy/module/micronumpy/interp_arrayops.py b/pypy/module/micronumpy/interp_arrayops.py
--- a/pypy/module/micronumpy/interp_arrayops.py
+++ b/pypy/module/micronumpy/interp_arrayops.py
@@ -65,7 +65,7 @@
[ 3., 4., -1.],
[-1., -1., -1.]])
-
+
NOTE: support for not passing x and y is unsupported
"""
if space.is_none(w_y):
@@ -122,10 +122,10 @@
for f in dtype.fields:
if f not in a_dt.fields or \
dtype.fields[f] != a_dt.fields[f]:
- raise OperationError(space.w_TypeError,
+ raise OperationError(space.w_TypeError,
space.wrap("record type mismatch"))
elif dtype.is_record_type() or a_dt.is_record_type():
- raise OperationError(space.w_TypeError,
+ raise OperationError(space.w_TypeError,
space.wrap("invalid type promotion"))
dtype = interp_ufuncs.find_binop_result_dtype(space, dtype,
arr.get_dtype())
@@ -192,6 +192,61 @@
loop.choose(space, arr, choices, shape, dtype, out, MODES[mode])
return out
+
+ at unwrap_spec(mode=str)
+def put(space, w_arr, w_indices, w_values, mode='raise'):
+ from pypy.module.micronumpy import constants
+ from pypy.module.micronumpy.support import int_w
+
+ arr = convert_to_array(space, w_arr)
+
+ if mode not in constants.MODES:
+ raise OperationError(space.w_ValueError,
+ space.wrap("mode %s not known" % (mode,)))
+ if not w_indices:
+ raise OperationError(space.w_ValueError,
+ space.wrap("indice list cannot be empty"))
+ if not w_values:
+ raise OperationError(space.w_ValueError,
+ space.wrap("value list cannot be empty"))
+
+ dtype = arr.get_dtype()
+
+ if space.isinstance_w(w_indices, space.w_list):
+ indices = space.listview(w_indices)
+ else:
+ indices = [w_indices]
+
+ if space.isinstance_w(w_values, space.w_list):
+ values = space.listview(w_values)
+ else:
+ values = [w_values]
+
+ v_idx = 0
+ for idx in indices:
+ index = int_w(space, idx)
+
+ if index < 0 or index >= arr.get_size():
+ if constants.MODES[mode] == constants.MODE_RAISE:
+ raise OperationError(space.w_ValueError, space.wrap(
+ "invalid entry in choice array"))
+ elif constants.MODES[mode] == constants.MODE_WRAP:
+ index = index % arr.get_size()
+ else:
+ assert constants.MODES[mode] == constants.MODE_CLIP
+ if index < 0:
+ index = 0
+ else:
+ index = arr.get_size() - 1
+
+ value = values[v_idx]
+
+ if v_idx + 1 < len(values):
+ v_idx += 1
+
+ arr.setitem(space, [index], dtype.coerce(space, value))
+
+
def diagonal(space, arr, offset, axis1, axis2):
shape = arr.get_shape()
shapelen = len(shape)
diff --git a/pypy/module/micronumpy/interp_boxes.py b/pypy/module/micronumpy/interp_boxes.py
--- a/pypy/module/micronumpy/interp_boxes.py
+++ b/pypy/module/micronumpy/interp_boxes.py
@@ -235,6 +235,21 @@
w_values = space.newtuple([self])
return convert_to_array(space, w_values)
+ @unwrap_spec(decimals=int)
+ def descr_round(self, space, decimals=0):
+ v = self.convert_to(self.get_dtype(space))
+ return self.get_dtype(space).itemtype.round(v, decimals)
+
+ def descr_view(self, space, w_dtype):
+ from pypy.module.micronumpy.interp_dtype import W_Dtype
+ dtype = space.interp_w(W_Dtype,
+ space.call_function(space.gettypefor(W_Dtype), w_dtype))
+ if dtype.get_size() != self.get_dtype(space).get_size():
+ raise OperationError(space.w_ValueError, space.wrap(
+ "new type not compatible with array."))
+ raise OperationError(space.w_NotImplementedError, space.wrap(
+ "view not implelemnted yet"))
+
class W_BoolBox(W_GenericBox, PrimitiveBox):
descr__new__, _get_dtype, descr_reduce = new_dtype_getter("bool")
@@ -501,6 +516,8 @@
any = interp2app(W_GenericBox.descr_any),
all = interp2app(W_GenericBox.descr_all),
ravel = interp2app(W_GenericBox.descr_ravel),
+ round = interp2app(W_GenericBox.descr_round),
+ view = interp2app(W_GenericBox.descr_view),
)
W_BoolBox.typedef = TypeDef("bool_", W_GenericBox.typedef,
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
@@ -550,17 +550,36 @@
raise OperationError(space.w_NotImplementedError, space.wrap(
"ptp (peak to peak) not implemented yet"))
- def descr_put(self, space, w_indices, w_values, w_mode='raise'):
- raise OperationError(space.w_NotImplementedError, space.wrap(
- "put not implemented yet"))
+ @unwrap_spec(mode=str)
+ def descr_put(self, space, w_indices, w_values, mode='raise'):
+ from pypy.module.micronumpy.interp_arrayops import put
+ put(space, self, w_indices, w_values, mode)
def descr_resize(self, space, w_new_shape, w_refcheck=True):
raise OperationError(space.w_NotImplementedError, space.wrap(
"resize not implemented yet"))
- def descr_round(self, space, w_decimals=0, w_out=None):
- raise OperationError(space.w_NotImplementedError, space.wrap(
- "round not implemented yet"))
+ @unwrap_spec(decimals=int)
+ def descr_round(self, space, decimals=0, w_out=None):
+ if space.is_none(w_out):
+ if self.get_dtype().is_bool_type():
+ #numpy promotes bool.round() to float16. Go figure.
+ w_out = W_NDimArray.from_shape(self.get_shape(),
+ interp_dtype.get_dtype_cache(space).w_float16dtype)
+ else:
+ w_out = None
+ elif not isinstance(w_out, W_NDimArray):
+ raise OperationError(space.w_TypeError, space.wrap(
+ "return arrays must be of ArrayType"))
+ out = interp_dtype.dtype_agreement(space, [self], self.get_shape(),
+ w_out)
+ if out.get_dtype().is_bool_type() and self.get_dtype().is_bool_type():
+ calc_dtype = interp_dtype.get_dtype_cache(space).w_longdtype
+ else:
+ calc_dtype = out.get_dtype()
+
+ loop.round(space, self, calc_dtype, self.get_shape(), decimals, out)
+ return out
def descr_searchsorted(self, space, w_v, w_side='left'):
raise OperationError(space.w_NotImplementedError, space.wrap(
@@ -600,8 +619,40 @@
"trace not implemented yet"))
def descr_view(self, space, w_dtype=None, w_type=None) :
- raise OperationError(space.w_NotImplementedError, space.wrap(
- "view not implemented yet"))
+ if w_type is not None:
+ raise OperationError(space.w_NotImplementedError, space.wrap(
+ "view(... type=<class>) not implemented yet"))
+ if w_dtype:
+ dtype = space.interp_w(interp_dtype.W_Dtype,
+ space.call_function(space.gettypefor(interp_dtype.W_Dtype),
+ w_dtype))
+ else:
+ dtype = self.get_dtype()
+ old_itemsize = self.get_dtype().get_size()
+ new_itemsize = dtype.get_size()
+ impl = self.implementation
+ new_shape = self.get_shape()[:]
+ dims = len(new_shape)
+ if dims == 0:
+ # Cannot resize scalars
+ if old_itemsize != new_itemsize:
+ raise OperationError(space.w_ValueError, space.wrap(
+ "new type not compatible with array shape"))
+ else:
+ if dims == 1 or impl.get_strides()[0] < impl.get_strides()[-1]:
+ # Column-major, resize first dimension
+ if new_shape[0] * old_itemsize % new_itemsize != 0:
+ raise OperationError(space.w_ValueError, space.wrap(
+ "new type not compatible with array."))
+ new_shape[0] = new_shape[0] * old_itemsize / new_itemsize
+ else:
+ # Row-major, resize last dimension
+ if new_shape[-1] * old_itemsize % new_itemsize != 0:
+ raise OperationError(space.w_ValueError, space.wrap(
+ "new type not compatible with array."))
+ new_shape[-1] = new_shape[-1] * old_itemsize / new_itemsize
+ return W_NDimArray(impl.get_view(self, dtype, new_shape))
+
# --------------------- operations ----------------------------
@@ -939,6 +990,7 @@
prod = interp2app(W_NDimArray.descr_prod),
max = interp2app(W_NDimArray.descr_max),
min = interp2app(W_NDimArray.descr_min),
+ put = interp2app(W_NDimArray.descr_put),
argmax = interp2app(W_NDimArray.descr_argmax),
argmin = interp2app(W_NDimArray.descr_argmin),
all = interp2app(W_NDimArray.descr_all),
@@ -975,8 +1027,10 @@
byteswap = interp2app(W_NDimArray.descr_byteswap),
choose = interp2app(W_NDimArray.descr_choose),
clip = interp2app(W_NDimArray.descr_clip),
+ round = interp2app(W_NDimArray.descr_round),
data = GetSetProperty(W_NDimArray.descr_get_data),
diagonal = interp2app(W_NDimArray.descr_diagonal),
+ view = interp2app(W_NDimArray.descr_view),
ctypes = GetSetProperty(W_NDimArray.descr_get_ctypes), # XXX unimplemented
__array_interface__ = GetSetProperty(W_NDimArray.descr_array_iface),
@@ -1009,15 +1063,21 @@
order)
dtype = interp_dtype.decode_w_dtype(space, w_dtype)
- if isinstance(w_object, W_NDimArray):
- if (not space.is_none(w_dtype) and
- w_object.get_dtype() is not dtype):
- raise OperationError(space.w_NotImplementedError, space.wrap(
- "copying over different dtypes unsupported"))
+ if isinstance(w_object, W_NDimArray) and \
+ (space.is_none(w_dtype) or w_object.get_dtype() is dtype):
+ shape = w_object.get_shape()
if copy:
- return w_object.descr_copy(space)
- return w_object
-
+ w_ret = w_object.descr_copy(space)
+ else:
+ if ndmin<= len(shape):
+ return w_object
+ new_impl = w_object.implementation.set_shape(space, w_object, shape)
+ w_ret = W_NDimArray(new_impl)
+ if ndmin > len(shape):
+ shape = [1] * (ndmin - len(shape)) + shape
+ w_ret.implementation = w_ret.implementation.set_shape(space,
+ w_ret, shape)
+ return w_ret
shape, elems_w = find_shape_and_elems(space, w_object, dtype)
if dtype is None or (
dtype.is_str_or_unicode() and dtype.itemtype.get_size() < 1):
diff --git a/pypy/module/micronumpy/interp_support.py b/pypy/module/micronumpy/interp_support.py
--- a/pypy/module/micronumpy/interp_support.py
+++ b/pypy/module/micronumpy/interp_support.py
@@ -2,7 +2,7 @@
from pypy.interpreter.gateway import unwrap_spec, WrappedDefault
from rpython.rtyper.lltypesystem import lltype, rffi
from pypy.module.micronumpy import interp_dtype, loop
-from pypy.objspace.std.strutil import strip_spaces
+from rpython.rlib.rstring import strip_spaces
from rpython.rlib.rarithmetic import maxint
from pypy.module.micronumpy.base import W_NDimArray
diff --git a/pypy/module/micronumpy/iter.py b/pypy/module/micronumpy/iter.py
--- a/pypy/module/micronumpy/iter.py
+++ b/pypy/module/micronumpy/iter.py
@@ -37,7 +37,7 @@
we can go faster.
All the calculations happen in next()
-next_skip_x() tries to do the iteration for a number of steps at once,
+next_skip_x(steps) tries to do the iteration for a number of steps at once,
but then we cannot gaurentee that we only overflow one single shape
dimension, perhaps we could overflow times in one big step.
"""
@@ -46,6 +46,7 @@
calculate_slice_strides
from pypy.module.micronumpy.base import W_NDimArray
from pypy.module.micronumpy.arrayimpl import base
+from pypy.module.micronumpy.support import product
from rpython.rlib import jit
# structures to describe slicing
@@ -225,7 +226,7 @@
self.shape = shape
self.offset = start
self.shapelen = len(shape)
- self._done = False
+ self._done = self.shapelen == 0 or product(shape) == 0
self.strides = strides
self.backstrides = backstrides
self.size = array.size
@@ -284,7 +285,7 @@
self.backstrides = backstrides[:dim] + [0] + backstrides[dim:]
self.first_line = True
self.indices = [0] * len(shape)
- self._done = False
+ self._done = array.get_size() == 0
self.offset = array.start
self.dim = dim
self.array = array
diff --git a/pypy/module/micronumpy/loop.py b/pypy/module/micronumpy/loop.py
--- a/pypy/module/micronumpy/loop.py
+++ b/pypy/module/micronumpy/loop.py
@@ -173,7 +173,7 @@
iter = x_iter
shapelen = len(shape)
while not iter.done():
- where_driver.jit_merge_point(shapelen=shapelen, dtype=dtype,
+ where_driver.jit_merge_point(shapelen=shapelen, dtype=dtype,
arr_dtype=arr_dtype)
w_cond = arr_iter.getitem()
if arr_dtype.itemtype.bool(w_cond):
@@ -188,7 +188,7 @@
return out
axis_reduce__driver = jit.JitDriver(name='numpy_axis_reduce',
- greens=['shapelen',
+ greens=['shapelen',
'func', 'dtype',
'identity'],
reds='auto')
@@ -228,7 +228,7 @@
arg_driver = jit.JitDriver(name='numpy_' + op_name,
greens = ['shapelen', 'dtype'],
reds = 'auto')
-
+
def argmin_argmax(arr):
result = 0
idx = 1
@@ -265,7 +265,7 @@
result.shape == [3, 5, 2, 4]
broadcast shape should be [3, 5, 2, 7, 4]
result should skip dims 3 which is len(result_shape) - 1
- (note that if right is 1d, result should
+ (note that if right is 1d, result should
skip len(result_shape))
left should skip 2, 4 which is a.ndims-1 + range(right.ndims)
except where it==(right.ndims-2)
@@ -283,9 +283,9 @@
righti = right.create_dot_iter(broadcast_shape, right_skip)
while not outi.done():
dot_driver.jit_merge_point(dtype=dtype)
- lval = lefti.getitem().convert_to(dtype)
- rval = righti.getitem().convert_to(dtype)
- outval = outi.getitem().convert_to(dtype)
+ lval = lefti.getitem().convert_to(dtype)
+ rval = righti.getitem().convert_to(dtype)
+ outval = outi.getitem().convert_to(dtype)
v = dtype.itemtype.mul(lval, rval)
value = dtype.itemtype.add(v, outval).convert_to(dtype)
outi.setitem(value)
@@ -355,7 +355,7 @@
setitem_filter_driver.jit_merge_point(shapelen=shapelen,
index_dtype=index_dtype,
arr_dtype=arr_dtype,
- )
+ )
if index_iter.getitem_bool():
arr_iter.setitem(value_iter.getitem())
value_iter.next()
@@ -572,6 +572,21 @@
out_iter.next()
min_iter.next()
+round_driver = jit.JitDriver(greens = ['shapelen', 'dtype'],
+ reds = 'auto')
+
+def round(space, arr, dtype, shape, decimals, out):
+ arr_iter = arr.create_iter(shape)
+ shapelen = len(shape)
+ out_iter = out.create_iter(shape)
+ while not arr_iter.done():
+ round_driver.jit_merge_point(shapelen=shapelen, dtype=dtype)
+ w_v = dtype.itemtype.round(arr_iter.getitem().convert_to(dtype),
+ decimals)
+ out_iter.setitem(w_v)
+ arr_iter.next()
+ out_iter.next()
+
diagonal_simple_driver = jit.JitDriver(greens = ['axis1', 'axis2'],
reds = 'auto')
@@ -613,4 +628,4 @@
out_iter.setitem(arr.getitem_index(space, indexes))
iter.next()
out_iter.next()
-
+
diff --git a/pypy/module/micronumpy/test/test_arrayops.py b/pypy/module/micronumpy/test/test_arrayops.py
--- a/pypy/module/micronumpy/test/test_arrayops.py
+++ b/pypy/module/micronumpy/test/test_arrayops.py
@@ -132,3 +132,26 @@
x = array([0, 0, 0], dtype='i2')
r = array([2, 1, 0]).choose([a, b, c], out=x)
assert r.dtype == 'i2'
+
+ def test_put_basic(self):
+ from numpypy import arange, array
+ a = arange(5)
+ a.put([0, 2], [-44, -55])
+ assert (a == array([-44, 1, -55, 3, 4])).all()
+ a = arange(5)
+ a.put([3, 4], 9)
+ assert (a == array([0, 1, 2, 9, 9])).all()
+ a = arange(5)
+ a.put(1, [7, 8])
+ assert (a == array([0, 7, 2, 3, 4])).all()
+
+ def test_put_modes(self):
+ from numpypy import array, arange
+ a = arange(5)
+ a.put(22, -5, mode='clip')
+ assert (a == array([0, 1, 2, 3, -5])).all()
+ a = arange(5)
+ a.put(22, -5, mode='wrap')
+ assert (a == array([0, 1, -5, 3, 4])).all()
+ raises(ValueError, "arange(5).put(22, -5, mode='raise')")
+ raises(ValueError, "arange(5).put(22, -5, mode='wrongmode')")
diff --git a/pypy/module/micronumpy/test/test_dtypes.py b/pypy/module/micronumpy/test/test_dtypes.py
--- a/pypy/module/micronumpy/test/test_dtypes.py
+++ b/pypy/module/micronumpy/test/test_dtypes.py
@@ -585,6 +585,7 @@
import numpypy as numpy
assert numpy.complex_ is numpy.complex128
+ assert numpy.cfloat is numpy.complex64
assert numpy.complex64.__mro__ == (numpy.complex64,
numpy.complexfloating, numpy.inexact, numpy.number, numpy.generic,
object)
diff --git a/pypy/module/micronumpy/test/test_iter.py b/pypy/module/micronumpy/test/test_iter.py
--- a/pypy/module/micronumpy/test/test_iter.py
+++ b/pypy/module/micronumpy/test/test_iter.py
@@ -1,4 +1,5 @@
from pypy.module.micronumpy.iter import MultiDimViewIterator
+from pypy.module.micronumpy.arrayimpl.scalar import ScalarIterator
class MockArray(object):
size = 1
@@ -8,7 +9,7 @@
#Let's get started, simple iteration in C order with
#contiguous layout => strides[-1] is 1
start = 0
- shape = [3, 5]
+ shape = [3, 5]
strides = [5, 1]
backstrides = [x * (y - 1) for x,y in zip(strides, shape)]
assert backstrides == [10, 4]
@@ -47,7 +48,7 @@
#iteration in C order with #contiguous layout => strides[-1] is 1
#skip less than the shape
start = 0
- shape = [3, 5]
+ shape = [3, 5]
strides = [5, 1]
backstrides = [x * (y - 1) for x,y in zip(strides, shape)]
assert backstrides == [10, 4]
@@ -89,3 +90,9 @@
assert i.indexes == [0,1]
assert i.offset == 3
assert i.done()
+
+ def test_scalar_iter(self):
+ i = ScalarIterator(MockArray)
+ i.next()
+ i.next_skip_x(3)
+ assert i.done()
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
@@ -276,6 +276,32 @@
arr = array([1], ndmin=3)
assert arr.shape == (1, 1, 1)
+ def test_array_copy(self):
+ from numpypy import array
+ a = array(range(12)).reshape(3,4)
+ b = array(a, ndmin=4)
+ assert b.shape == (1, 1, 3, 4)
+ b = array(a, copy=False)
+ b[0, 0] = 100
+ assert a[0, 0] == 100
+ b = array(a, copy=True, ndmin=2)
+ b[0, 0] = 0
+ assert a[0, 0] == 100
+ b = array(a, dtype=float)
+ assert (b[0] == [100, 1, 2, 3]).all()
+ assert b.dtype.kind == 'f'
+ b = array(a, copy=False, ndmin=4)
+ b[0,0,0,0] = 0
+ assert a[0, 0] == 0
+ a = array([[[]]])
+ # Simulate tiling an empty array, really tests repeat, reshape
+ # b = tile(a, (3, 2, 5))
+ reps = (3, 4, 5)
+ c = array(a, copy=False, subok=True, ndmin=len(reps))
+ d = c.reshape(3, 4, 0)
+ e = d.repeat(3, 0)
+ assert e.shape == (9, 4, 0)
+
def test_type(self):
from numpypy import array
ar = array(range(5))
@@ -325,13 +351,16 @@
assert a[1] == 1.0
def test_ones(self):
- from numpypy import ones
+ from numpypy import ones, dtype
a = ones(3)
assert len(a) == 3
assert a[0] == 1
raises(IndexError, "a[3]")
a[2] = 4
assert a[2] == 4
+ b = ones(3, complex)
+ assert b[0] == 1+0j
+ assert b.dtype is dtype(complex)
def test_copy(self):
from numpypy import arange, array
@@ -1390,6 +1419,45 @@
assert a[3].imag == -10
assert a[2].imag == -5
+ def test_view(self):
+ from numpypy import array, int8, int16, dtype
+ x = array((1, 2), dtype=int8)
+ assert x.shape == (2,)
+ y = x.view(dtype=int16)
+ assert x.shape == (2,)
+ assert y[0] == 513
+ assert y.dtype == dtype('int16')
+ y[0] = 670
+ assert x[0] == -98
+ assert x[1] == 2
+ f = array([1000, -1234], dtype='i4')
+ nnp = self.non_native_prefix
+ d = f.view(dtype=nnp + 'i4')
+ assert (d == [-402456576, 788267007]).all()
+ x = array(range(15), dtype='i2').reshape(3,5)
+ exc = raises(ValueError, x.view, dtype='i4')
+ assert exc.value[0] == "new type not compatible with array."
+ assert x.view('int8').shape == (3, 10)
+ x = array(range(15), dtype='int16').reshape(3,5).T
+ assert x.view('int8').shape == (10, 3)
+
+ def test_ndarray_view_empty(self):
+ from numpypy import array, int8, int16, dtype
+ x = array([], dtype=[('a', int8), ('b', int8)])
+ y = x.view(dtype=int16)
+
+ def test_scalar_view(self):
+ from numpypy import int64, array
+ a = array(0, dtype='int32')
+ b = a.view(dtype='float32')
+ assert b.shape == ()
+ assert b == 0
+ s = int64(12)
+ exc = raises(ValueError, s.view, 'int8')
+ assert exc.value[0] == "new type not compatible with array."
+ skip('not implemented yet')
+ assert s.view('double') < 7e-323
+
def test_tolist_scalar(self):
from numpypy import int32, bool_
x = int32(23)
@@ -2176,6 +2244,10 @@
d.fill(100)
assert d == 100
+ e = array(10, dtype=complex)
+ e.fill(1.5-3j)
+ assert e == 1.5-3j
+
def test_array_indexing_bool(self):
from numpypy import arange
a = arange(10)
@@ -2498,6 +2570,9 @@
a = array(range(100) + range(100) + range(100))
b = a.argsort()
assert (b[:3] == [0, 100, 200]).all()
+ a = array([[[]]]).reshape(3,4,0)
+ b = a.argsort()
+ assert b.size == 0
def test_argsort_random(self):
from numpypy import array
diff --git a/pypy/module/micronumpy/test/test_scalar.py b/pypy/module/micronumpy/test/test_scalar.py
--- a/pypy/module/micronumpy/test/test_scalar.py
+++ b/pypy/module/micronumpy/test/test_scalar.py
@@ -21,3 +21,19 @@
a = zeros(3)
assert loads(dumps(sum(a))) == sum(a)
+
+ def test_round(self):
+ from numpypy import int32, float64, complex128, bool
+ i = int32(1337)
+ f = float64(13.37)
+ c = complex128(13 + 37.j)
+ b = bool(0)
+ assert i.round(decimals=-2) == 1300
+ assert i.round(decimals=1) == 1337
+ assert c.round() == c
+ assert f.round() == 13.
+ assert f.round(decimals=-1) == 10.
+ assert f.round(decimals=1) == 13.4
+ exc = raises(AttributeError, 'b.round()')
+ assert exc.value[0] == "'bool' object has no attribute 'round'"
+
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
@@ -286,7 +286,7 @@
skip('sign of nan is non-determinant')
assert (signbit([float('nan'), float('-nan'), -float('nan')]) ==
- [False, True, True]).all()
+ [False, True, True]).all()
def test_reciprocal(self):
from numpypy import array, reciprocal, complex64, complex128
@@ -334,6 +334,23 @@
assert all([math.copysign(1, f(abs(float("nan")))) == 1 for f in floor, ceil, trunc])
assert all([math.copysign(1, f(-abs(float("nan")))) == -1 for f in floor, ceil, trunc])
+ def test_round(self):
+ from numpypy import array, dtype
+ ninf, inf = float("-inf"), float("inf")
+ a = array([ninf, -1.4, -1.5, -1.0, 0.0, 1.0, 1.4, 0.5, inf])
+ assert ([ninf, -1.0, -2.0, -1.0, 0.0, 1.0, 1.0, 0.0, inf] == a.round()).all()
+ i = array([-1000, -100, -1, 0, 1, 111, 1111, 11111], dtype=int)
+ assert (i == i.round()).all()
+ assert (i.round(decimals=4) == i).all()
+ assert (i.round(decimals=-4) == [0, 0, 0, 0, 0, 0, 0, 10000]).all()
+ b = array([True, False], dtype=bool)
+ bround = b.round()
+ assert (bround == [1., 0.]).all()
+ assert bround.dtype is dtype('float16')
+ c = array([10.5+11.5j, -15.2-100.3456j, 0.2343+11.123456j])
+ assert (c.round(0) == [10.+12.j, -15-100j, 0+11j]).all()
+
+
def test_copysign(self):
from numpypy import array, copysign
@@ -364,7 +381,7 @@
assert b[i] == res
def test_exp2(self):
- import math
+ import math
from numpypy import array, exp2
inf = float('inf')
ninf = -float('inf')
@@ -759,8 +776,8 @@
complex(inf, inf), complex(inf, ninf), complex(0, inf),
complex(ninf, ninf), complex(nan, 0), complex(0, nan),
complex(nan, nan)]
- assert (isfinite(a) == [True, True, False, False, False,
- False, False, False, False, False]).all()
+ assert (isfinite(a) == [True, True, False, False, False,
+ False, False, False, False, False]).all()
def test_logical_ops(self):
from numpypy import logical_and, logical_or, logical_xor, logical_not
@@ -864,7 +881,7 @@
#numpy returns (a.real*b.real + a.imag*b.imag) / abs(b)**2
expect = [3., -23., 1.]
for i in range(len(a)):
- assert b[i] == expect[i]
+ assert b[i] == expect[i]
b = floor_divide(a[0], 0.)
assert math.isnan(b.real)
assert b.imag == 0.
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
@@ -37,7 +37,7 @@
return self.box(
func(
self,
- self.for_computation(raw)
+ self.for_computation(raw),
)
)
return dispatcher
@@ -521,6 +521,23 @@
return v
return 0
+ @specialize.argtype(1)
+ def round(self, v, decimals=0):
+ raw = self.for_computation(self.unbox(v))
+ if decimals < 0:
+ # No ** in rpython
+ factor = 1
+ for i in xrange(-decimals):
+ factor *=10
+ #int does floor division, we want toward zero
+ if raw < 0:
+ ans = - (-raw / factor * factor)
+ else:
+ ans = raw / factor * factor
+ else:
+ ans = raw
+ return self.box(ans)
+
@raw_unary_op
def signbit(self, v):
return v < 0
@@ -798,6 +815,16 @@
def ceil(self, v):
return math.ceil(v)
+ @specialize.argtype(1)
+ def round(self, v, decimals=0):
+ raw = self.for_computation(self.unbox(v))
+ if rfloat.isinf(raw):
+ return v
+ elif rfloat.isnan(raw):
+ return v
+ ans = rfloat.round_double(raw, decimals, half_even=True)
+ return self.box(ans)
+
@simple_unary_op
def trunc(self, v):
if v < 0:
@@ -1073,6 +1100,13 @@
op = '+' if imag >= 0 else ''
return ''.join(['(', real_str, op, imag_str, ')'])
+ def fill(self, storage, width, box, start, stop, offset):
+ real, imag = self.unbox(box)
+ for i in xrange(start, stop, width):
+ raw_storage_setitem(storage, i+offset, real)
+ raw_storage_setitem(storage,
+ i+offset+rffi.sizeof(self.T), imag)
+
@staticmethod
def for_computation(v):
return float(v[0]), float(v[1])
@@ -1354,6 +1388,15 @@
except ZeroDivisionError:
return rfloat.NAN, rfloat.NAN
+ @specialize.argtype(1)
+ def round(self, v, decimals=0):
+ ans = list(self.for_computation(self.unbox(v)))
+ if isfinite(ans[0]):
+ ans[0] = rfloat.round_double(ans[0], decimals, half_even=True)
+ if isfinite(ans[1]):
+ ans[1] = rfloat.round_double(ans[1], decimals, half_even=True)
+ return self.box_complex(ans[0], ans[1])
+
# No floor, ceil, trunc in numpy for complex
#@simple_unary_op
#def floor(self, v):
diff --git a/pypy/module/pypyjit/test_pypy_c/model.py b/pypy/module/pypyjit/test_pypy_c/model.py
--- a/pypy/module/pypyjit/test_pypy_c/model.py
+++ b/pypy/module/pypyjit/test_pypy_c/model.py
@@ -131,18 +131,19 @@
def has_id(self, id):
return id in self.ids
- def _ops_for_chunk(self, chunk, include_debug_merge_points):
+ def _ops_for_chunk(self, chunk, include_guard_not_invalidated):
for op in chunk.operations:
- if op.name != 'debug_merge_point' or include_debug_merge_points:
+ if op.name != 'debug_merge_point' and \
+ (op.name != 'guard_not_invalidated' or include_guard_not_invalidated):
yield op
- def _allops(self, include_debug_merge_points=False, opcode=None):
+ def _allops(self, opcode=None, include_guard_not_invalidated=True):
opcode_name = opcode
for chunk in self.flatten_chunks():
opcode = chunk.getopcode()
if opcode_name is None or \
(opcode and opcode.__class__.__name__ == opcode_name):
- for op in self._ops_for_chunk(chunk, include_debug_merge_points):
+ for op in self._ops_for_chunk(chunk, include_guard_not_invalidated):
yield op
else:
for op in chunk.operations:
@@ -162,15 +163,15 @@
def print_ops(self, *args, **kwds):
print self.format_ops(*args, **kwds)
- def _ops_by_id(self, id, include_debug_merge_points=False, opcode=None):
+ def _ops_by_id(self, id, include_guard_not_invalidated=True, opcode=None):
opcode_name = opcode
target_opcodes = self.ids[id]
- loop_ops = self.allops(include_debug_merge_points, opcode)
+ loop_ops = self.allops(opcode)
for chunk in self.flatten_chunks():
opcode = chunk.getopcode()
if opcode in target_opcodes and (opcode_name is None or
opcode.__class__.__name__ == opcode_name):
- for op in self._ops_for_chunk(chunk, include_debug_merge_points):
+ for op in self._ops_for_chunk(chunk, include_guard_not_invalidated):
if op in loop_ops:
yield op
diff --git a/pypy/module/pypyjit/test_pypy_c/test_containers.py b/pypy/module/pypyjit/test_pypy_c/test_containers.py
--- a/pypy/module/pypyjit/test_pypy_c/test_containers.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_containers.py
@@ -201,10 +201,27 @@
def main(n):
i = 0
while i < n:
- s = set([1,2,3])
+ s = set([1, 2, 3])
i += 1
log = self.run(main, [1000])
assert log.result == main(1000)
loop, = log.loops_by_filename(self.filepath)
opnames = log.opnames(loop.allops())
assert opnames.count('new_with_vtable') == 0
+
+ def test_specialised_tuple(self):
+ def main(n):
+ import pypyjit
+
+ f = lambda: None
+ tup = (n, n)
+ while n > 0:
+ tup[0] # ID: getitem
+ pypyjit.residual_call(f)
+ n -= 1
+
+ log = self.run(main, [1000])
+ assert log.result == main(1000)
+ loop, = log.loops_by_filename(self.filepath)
+ ops = loop.ops_by_id('getitem', include_guard_not_invalidated=False)
+ assert log.opnames(ops) == []
diff --git a/pypy/module/pypyjit/test_pypy_c/test_string.py b/pypy/module/pypyjit/test_pypy_c/test_string.py
--- a/pypy/module/pypyjit/test_pypy_c/test_string.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_string.py
@@ -80,39 +80,11 @@
i23 = strgetitem(p10, i19)
p25 = newstr(1)
strsetitem(p25, 0, i23)
- p28 = call(ConstClass(strip_spaces), p25, descr=<Callr . r EF=4>)
+ p93 = call(ConstClass(fromstr), p25, 16, descr=<Callr . ri EF=3>)
guard_no_exception(descr=...)
- i29 = strlen(p28)
- i30 = int_is_true(i29)
- guard_true(i30, descr=...)
- i32 = int_sub(i29, 1)
- i33 = strgetitem(p28, i32)
- i35 = int_eq(i33, 108)
- guard_false(i35, descr=...)
- i37 = int_eq(i33, 76)
- guard_false(i37, descr=...)
- i39 = strgetitem(p28, 0)
- i41 = int_eq(i39, 45)
- guard_false(i41, descr=...)
- i43 = int_eq(i39, 43)
- guard_false(i43, descr=...)
- i43 = call(ConstClass(ll_startswith__rpy_stringPtr_rpy_stringPtr), p28, ConstPtr(ptr42), descr=<Calli 1 rr EF=0>)
- guard_false(i43, descr=...)
- i46 = call(ConstClass(ll_startswith__rpy_stringPtr_rpy_stringPtr), p28, ConstPtr(ptr45), descr=<Calli 1 rr EF=0>)
- guard_false(i46, descr=...)
- p51 = new_with_vtable(...)
- setfield_gc(p51, _, descr=...) # 7 setfields, but the order is dict-order-dependent
- setfield_gc(p51, _, descr=...)
- setfield_gc(p51, _, descr=...)
- setfield_gc(p51, _, descr=...)
- setfield_gc(p51, _, descr=...)
- setfield_gc(p51, _, descr=...)
- setfield_gc(p51, _, descr=...)
- p55 = call(ConstClass(parse_digit_string), p51, descr=<Callr . r EF=4>)
+ i94 = call(ConstClass(rbigint.toint), p93, descr=<Calli . r EF=3>)
guard_no_exception(descr=...)
- i57 = call(ConstClass(rbigint.toint), p55, descr=<Calli . r EF=3>)
- guard_no_exception(descr=...)
- i58 = int_add_ovf(i6, i57)
+ i95 = int_add_ovf(i6, i94)
guard_no_overflow(descr=...)
--TICK--
jump(..., descr=...)
diff --git a/pypy/module/test_lib_pypy/test_ctypes_config_cache.py b/pypy/module/test_lib_pypy/test_ctypes_config_cache.py
--- a/pypy/module/test_lib_pypy/test_ctypes_config_cache.py
+++ b/pypy/module/test_lib_pypy/test_ctypes_config_cache.py
@@ -32,14 +32,6 @@
return d
-def test_syslog():
- try:
- import lib_pypy.syslog
- except ImportError:
- py.test.skip('no syslog on this platform')
- d = run('syslog.ctc.py', '_syslog_cache.py')
- assert 'LOG_NOTICE' in d
-
def test_resource():
try:
import lib_pypy.resource
diff --git a/pypy/module/test_lib_pypy/test_greenlet.py b/pypy/module/test_lib_pypy/test_greenlet.py
--- a/pypy/module/test_lib_pypy/test_greenlet.py
+++ b/pypy/module/test_lib_pypy/test_greenlet.py
@@ -319,3 +319,25 @@
g = G(lambda: 42)
x = g.switch()
assert x == 42
+
+ def test_kwargs_to_f(self):
+ import greenlet
+ seen = []
+ def f(*args, **kwds):
+ seen.append([args, kwds])
+ g = greenlet.greenlet(f)
+ g.switch(1, 2, x=3, y=4)
+ assert seen == [[(1, 2), {'x': 3, 'y': 4}]]
+
+ def test_kwargs_to_switch(self):
+ import greenlet
+ main = greenlet.getcurrent()
+ assert main.switch() == ()
+ assert main.switch(5) == 5
+ assert main.switch(5, 6) == (5, 6)
+ #
+ assert main.switch(x=5) == {'x': 5}
+ assert main.switch(x=5, y=6) == {'x': 5, 'y': 6}
+ assert main.switch(3, x=5) == ((3,), {'x': 5})
+ assert main.switch(3, x=5, y=6) == ((3,), {'x': 5, 'y': 6})
+ assert main.switch(2, 3, x=6) == ((2, 3), {'x': 6})
diff --git a/pypy/module/test_lib_pypy/test_grp_extra.py b/pypy/module/test_lib_pypy/test_grp_extra.py
--- a/pypy/module/test_lib_pypy/test_grp_extra.py
+++ b/pypy/module/test_lib_pypy/test_grp_extra.py
@@ -5,6 +5,22 @@
except ImportError:
py.test.skip("No grp module on this platform")
+def test_basic():
+ g = grp.getgrnam("root")
+ assert g.gr_gid == 0
+ assert g.gr_mem == ['root'] or g.gr_mem == []
+ assert g.gr_name == 'root'
+ assert isinstance(g.gr_passwd, str) # usually just 'x', don't hope :-)
+
def test_extra():
py.test.raises(TypeError, grp.getgrnam, False)
py.test.raises(TypeError, grp.getgrnam, None)
+
+def test_struct_group():
+ g = grp.struct_group((10, 20, 30, 40))
+ assert len(g) == 4
+ assert list(g) == [10, 20, 30, 40]
+ assert g.gr_name == 10
+ assert g.gr_passwd == 20
+ assert g.gr_gid == 30
+ assert g.gr_mem == 40
diff --git a/pypy/module/test_lib_pypy/test_syslog.py b/pypy/module/test_lib_pypy/test_syslog.py
--- a/pypy/module/test_lib_pypy/test_syslog.py
+++ b/pypy/module/test_lib_pypy/test_syslog.py
@@ -1,15 +1,15 @@
from __future__ import absolute_import
-import py
+import sys, py
try:
from lib_pypy import syslog
except ImportError:
py.test.skip('no syslog on this platform')
+except AssertionError:
+ if '__pypy__' in sys.builtin_module_names:
+ raise
+ py.test.skip('AssertionError during import (wrong cffi version?)')
# XXX very minimal test
-from lib_pypy.ctypes_config_cache import rebuild
-rebuild.rebuild_one('syslog.ctc.py')
-
-
def test_syslog():
assert hasattr(syslog, 'LOG_ALERT')
diff --git a/pypy/objspace/std/complextype.py b/pypy/objspace/std/complextype.py
--- a/pypy/objspace/std/complextype.py
+++ b/pypy/objspace/std/complextype.py
@@ -1,10 +1,11 @@
from pypy.interpreter.gateway import interp2app, unwrap_spec, WrappedDefault
from pypy.interpreter.error import OperationError, operationerrfmt
from pypy.objspace.std.register_all import register_all
-from pypy.objspace.std.strutil import string_to_float, ParseStringError
from pypy.objspace.std.noneobject import W_NoneObject
from pypy.objspace.std.stdtypedef import GetSetProperty, StdTypeDef
from pypy.objspace.std.stdtypedef import StdObjSpaceMultiMethod
+from rpython.rlib.rfloat import string_to_float
+from rpython.rlib.rstring import ParseStringError
# ERRORCODES
diff --git a/pypy/objspace/std/dictmultiobject.py b/pypy/objspace/std/dictmultiobject.py
--- a/pypy/objspace/std/dictmultiobject.py
+++ b/pypy/objspace/std/dictmultiobject.py
@@ -225,8 +225,8 @@
space.raise_key_error(w_key)
def descr_reversed(self, space):
- raise OperationError(space.w_TypeError, space.wrap(
- 'argument to reversed() must be a sequence'))
+ raise operationerrfmt(space.w_TypeError,
+ 'argument to reversed() must be a sequence')
def descr_copy(self, space):
"""D.copy() -> a shallow copy of D"""
diff --git a/pypy/objspace/std/floattype.py b/pypy/objspace/std/floattype.py
--- a/pypy/objspace/std/floattype.py
+++ b/pypy/objspace/std/floattype.py
@@ -8,10 +8,9 @@
from pypy.interpreter.error import OperationError
from pypy.objspace.std.register_all import register_all
from pypy.objspace.std.stdtypedef import StdTypeDef, SMM
-from pypy.objspace.std.strutil import ParseStringError
-from pypy.objspace.std.strutil import string_to_float
from pypy.objspace.std.model import W_Object
from rpython.rlib.rbigint import rbigint
+from rpython.rlib.rstring import ParseStringError
float_as_integer_ratio = SMM("as_integer_ratio", 1)
@@ -41,7 +40,7 @@
space.isinstance_w(w_value, space.w_bytearray)):
strvalue = space.bufferstr_w(w_value)
try:
- value = string_to_float(strvalue)
+ value = rfloat.string_to_float(strvalue)
except ParseStringError, e:
raise OperationError(space.w_ValueError,
space.wrap(e.msg))
@@ -49,7 +48,7 @@
from unicodeobject import unicode_to_decimal_w
strvalue = unicode_to_decimal_w(space, w_value)
try:
- value = string_to_float(strvalue)
+ value = rfloat.string_to_float(strvalue)
except ParseStringError, e:
raise OperationError(space.w_ValueError,
space.wrap(e.msg))
diff --git a/pypy/objspace/std/inttype.py b/pypy/objspace/std/inttype.py
--- a/pypy/objspace/std/inttype.py
+++ b/pypy/objspace/std/inttype.py
@@ -5,13 +5,12 @@
from pypy.interpreter.buffer import Buffer
from pypy.objspace.std.register_all import register_all
from pypy.objspace.std.stdtypedef import StdTypeDef, SMM
-from pypy.objspace.std.strutil import (string_to_int, string_to_bigint,
- ParseStringError,
- ParseStringOverflowError)
from pypy.objspace.std.model import W_Object
-from rpython.rlib.rarithmetic import r_uint
+from rpython.rlib.rarithmetic import r_uint, string_to_int
from rpython.rlib.objectmodel import instantiate
from rpython.rlib.rbigint import rbigint
+from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError
+from rpython.rlib import jit
# ____________________________________________________________
@@ -63,6 +62,7 @@
# ____________________________________________________________
+ at jit.elidable
def string_to_int_or_long(space, string, base=10):
w_longval = None
value = 0
@@ -75,15 +75,14 @@
w_longval = retry_to_w_long(space, e.parser)
return value, w_longval
-def retry_to_w_long(space, parser, base=0):
+def retry_to_w_long(space, parser):
parser.rewind()
try:
- bigint = string_to_bigint(None, base=base, parser=parser)
+ bigint = rbigint._from_numberstring_parser(parser)
except ParseStringError, e:
raise OperationError(space.w_ValueError,
space.wrap(e.msg))
- from pypy.objspace.std.longobject import newlong
- return newlong(space, bigint)
+ return space.newlong_from_rbigint(bigint)
@unwrap_spec(w_x = WrappedDefault(0))
def descr__new__(space, w_inttype, w_x, w_base=None):
diff --git a/pypy/objspace/std/listobject.py b/pypy/objspace/std/listobject.py
--- a/pypy/objspace/std/listobject.py
+++ b/pypy/objspace/std/listobject.py
@@ -1222,7 +1222,8 @@
def _safe_find(self, w_list, obj, start, stop):
l = self.unerase(w_list.lstorage)
for i in range(start, min(stop, len(l))):
- if l[i] == obj:
+ val = l[i]
+ if val == obj:
return i
raise ValueError
@@ -1542,18 +1543,6 @@
if reverse:
l.reverse()
- def _safe_find(self, w_list, obj, start, stop):
- from rpython.rlib.rfloat import isnan
- if not isnan(obj):
- return AbstractUnwrappedStrategy._safe_find(self, w_list, obj,
More information about the pypy-commit
mailing list