[pypy-commit] pypy reflex-support: merge default into branch
wlav
noreply at buildbot.pypy.org
Tue Sep 3 20:45:11 CEST 2013
Author: Wim Lavrijsen <WLavrijsen at lbl.gov>
Branch: reflex-support
Changeset: r66779:aebf8cc7108a
Date: 2013-09-03 11:43 -0700
http://bitbucket.org/pypy/pypy/changeset/aebf8cc7108a/
Log: merge default into branch
diff too long, truncating to 2000 out of 10055 lines
diff --git a/lib-python/2.7/uuid.py b/lib-python/2.7/uuid.py
--- a/lib-python/2.7/uuid.py
+++ b/lib-python/2.7/uuid.py
@@ -44,6 +44,8 @@
UUID('00010203-0405-0607-0809-0a0b0c0d0e0f')
"""
+import struct
+
__author__ = 'Ka-Ping Yee <ping at zesty.ca>'
RESERVED_NCS, RFC_4122, RESERVED_MICROSOFT, RESERVED_FUTURE = [
@@ -125,25 +127,38 @@
overriding the given 'hex', 'bytes', 'bytes_le', 'fields', or 'int'.
"""
- if [hex, bytes, bytes_le, fields, int].count(None) != 4:
- raise TypeError('need one of hex, bytes, bytes_le, fields, or int')
if hex is not None:
+ if (bytes is not None or bytes_le is not None or fields is not None
+ or int is not None):
+ raise TypeError('if the hex argument is given, bytes, bytes_le, fields,'
+ ' and int need to be None')
hex = hex.replace('urn:', '').replace('uuid:', '')
hex = hex.strip('{}').replace('-', '')
if len(hex) != 32:
raise ValueError('badly formed hexadecimal UUID string')
int = long(hex, 16)
- if bytes_le is not None:
+ elif bytes_le is not None:
+ if bytes is not None or fields is not None or int is not None:
+ raise TypeError('if the bytes_le argument is given, bytes, fields,'
+ ' and int need to be None')
if len(bytes_le) != 16:
raise ValueError('bytes_le is not a 16-char string')
bytes = (bytes_le[3] + bytes_le[2] + bytes_le[1] + bytes_le[0] +
bytes_le[5] + bytes_le[4] + bytes_le[7] + bytes_le[6] +
bytes_le[8:])
- if bytes is not None:
+ int = (struct.unpack('>Q', bytes[:8])[0] << 64 |
+ struct.unpack('>Q', bytes[8:])[0])
+ elif bytes is not None:
+ if fields is not None or int is not None:
+ raise TypeError('if the bytes argument is given, fields'
+ ' and int need to be None')
if len(bytes) != 16:
raise ValueError('bytes is not a 16-char string')
- int = long(('%02x'*16) % tuple(map(ord, bytes)), 16)
- if fields is not None:
+ int = (struct.unpack('>Q', bytes[:8])[0] << 64 |
+ struct.unpack('>Q', bytes[8:])[0])
+ elif fields is not None:
+ if int is not None:
+ raise TypeError('if the fields argument is given, int needs to be None')
if len(fields) != 6:
raise ValueError('fields is not a 6-tuple')
(time_low, time_mid, time_hi_version,
@@ -163,9 +178,12 @@
clock_seq = (clock_seq_hi_variant << 8L) | clock_seq_low
int = ((time_low << 96L) | (time_mid << 80L) |
(time_hi_version << 64L) | (clock_seq << 48L) | node)
- if int is not None:
+ elif int is not None:
if not 0 <= int < 1<<128L:
raise ValueError('int is out of range (need a 128-bit value)')
+ else:
+ raise TypeError('one of hex, bytes, bytes_le, fields,'
+ ' or int need to be not None')
if version is not None:
if not 1 <= version <= 5:
raise ValueError('illegal version number')
@@ -175,7 +193,7 @@
# Set the version number.
int &= ~(0xf000 << 64L)
int |= version << 76L
- self.__dict__['int'] = int
+ object.__setattr__(self, 'int', int)
def __cmp__(self, other):
if isinstance(other, UUID):
diff --git a/lib_pypy/_curses.py b/lib_pypy/_curses.py
--- a/lib_pypy/_curses.py
+++ b/lib_pypy/_curses.py
@@ -1,6 +1,9 @@
"""Reimplementation of the standard extension module '_curses' using cffi."""
import sys
+if sys.platform == 'win32':
+ #This module does not exist in windows
+ raise ImportError('No module named _curses')
from functools import wraps
from cffi import FFI
diff --git a/lib_pypy/_sqlite3.py b/lib_pypy/_sqlite3.py
--- a/lib_pypy/_sqlite3.py
+++ b/lib_pypy/_sqlite3.py
@@ -1229,7 +1229,10 @@
if cvt is not None:
param = cvt(param)
- param = adapt(param)
+ try:
+ param = adapt(param)
+ except:
+ pass # And use previous value
if param is None:
rc = _lib.sqlite3_bind_null(self._statement, idx)
diff --git a/lib_pypy/cffi/__init__.py b/lib_pypy/cffi/__init__.py
--- a/lib_pypy/cffi/__init__.py
+++ b/lib_pypy/cffi/__init__.py
@@ -4,5 +4,5 @@
from .api import FFI, CDefError, FFIError
from .ffiplatform import VerificationError, VerificationMissing
-__version__ = "0.7"
-__version_info__ = (0, 7)
+__version__ = "0.7.2"
+__version_info__ = (0, 7, 2)
diff --git a/lib_pypy/cffi/api.py b/lib_pypy/cffi/api.py
--- a/lib_pypy/cffi/api.py
+++ b/lib_pypy/cffi/api.py
@@ -54,7 +54,8 @@
# _cffi_backend.so compiled.
import _cffi_backend as backend
from . import __version__
- assert backend.__version__ == __version__
+ assert (backend.__version__ == __version__ or
+ backend.__version__ == __version__[:3])
# (If you insist you can also try to pass the option
# 'backend=backend_ctypes.CTypesBackend()', but don't
# rely on it! It's probably not going to work well.)
diff --git a/lib_pypy/cffi/commontypes.py b/lib_pypy/cffi/commontypes.py
--- a/lib_pypy/cffi/commontypes.py
+++ b/lib_pypy/cffi/commontypes.py
@@ -30,7 +30,9 @@
elif result in model.PrimitiveType.ALL_PRIMITIVE_TYPES:
result = model.PrimitiveType(result)
else:
- assert commontype != result
+ if commontype == result:
+ raise api.FFIError("Unsupported type: %r. Please file a bug "
+ "if you think it should be." % (commontype,))
result = resolve_common_type(result) # recursively
assert isinstance(result, model.BaseTypeByIdentity)
_CACHE[commontype] = result
diff --git a/lib_pypy/cffi/cparser.py b/lib_pypy/cffi/cparser.py
--- a/lib_pypy/cffi/cparser.py
+++ b/lib_pypy/cffi/cparser.py
@@ -290,13 +290,26 @@
# assume a primitive type. get it from .names, but reduce
# synonyms to a single chosen combination
names = list(type.names)
- if names == ['signed'] or names == ['unsigned']:
- names.append('int')
- if names[0] == 'signed' and names != ['signed', 'char']:
- names.pop(0)
- if (len(names) > 1 and names[-1] == 'int'
- and names != ['unsigned', 'int']):
- names.pop()
+ if names != ['signed', 'char']: # keep this unmodified
+ prefixes = {}
+ while names:
+ name = names[0]
+ if name in ('short', 'long', 'signed', 'unsigned'):
+ prefixes[name] = prefixes.get(name, 0) + 1
+ del names[0]
+ else:
+ break
+ # ignore the 'signed' prefix below, and reorder the others
+ newnames = []
+ for prefix in ('unsigned', 'short', 'long'):
+ for i in range(prefixes.get(prefix, 0)):
+ newnames.append(prefix)
+ if not names:
+ names = ['int'] # implicitly
+ if names == ['int']: # but kill it if 'short' or 'long'
+ if 'short' in prefixes or 'long' in prefixes:
+ names = []
+ names = newnames + names
ident = ' '.join(names)
if ident == 'void':
return model.void_type
@@ -500,8 +513,8 @@
self._partial_length = True
return None
#
- raise api.FFIError("unsupported non-constant or "
- "not immediately constant expression")
+ raise api.FFIError("unsupported expression: expected a "
+ "simple numeric constant")
def _build_enum_type(self, explicit_name, decls):
if decls is not None:
diff --git a/lib_pypy/cffi/vengine_gen.py b/lib_pypy/cffi/vengine_gen.py
--- a/lib_pypy/cffi/vengine_gen.py
+++ b/lib_pypy/cffi/vengine_gen.py
@@ -61,7 +61,9 @@
def load_library(self):
# import it with the CFFI backend
backend = self.ffi._backend
- module = backend.load_library(self.verifier.modulefilename)
+ # needs to make a path that contains '/', on Posix
+ filename = os.path.join(os.curdir, self.verifier.modulefilename)
+ module = backend.load_library(filename)
#
# call loading_gen_struct() to get the struct layout inferred by
# the C compiler
diff --git a/lib_pypy/datetime.py b/lib_pypy/datetime.py
--- a/lib_pypy/datetime.py
+++ b/lib_pypy/datetime.py
@@ -40,9 +40,9 @@
# for all computations. See the book for algorithms for converting between
# proleptic Gregorian ordinals and many other calendar systems.
-_DAYS_IN_MONTH = [None, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+_DAYS_IN_MONTH = [-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-_DAYS_BEFORE_MONTH = [None]
+_DAYS_BEFORE_MONTH = [-1]
dbm = 0
for dim in _DAYS_IN_MONTH[1:]:
_DAYS_BEFORE_MONTH.append(dbm)
diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py
--- a/pypy/config/pypyoption.py
+++ b/pypy/config/pypyoption.py
@@ -127,11 +127,6 @@
pypy_optiondescription = OptionDescription("objspace", "Object Space Options", [
- OptionDescription("opcodes", "opcodes to enable in the interpreter", [
- BoolOption("CALL_METHOD", "emit a special bytecode for expr.name()",
- default=False),
- ]),
-
OptionDescription("usemodules", "Which Modules should be used", [
BoolOption(modname, "use module %s" % (modname, ),
default=modname in default_modules,
@@ -259,9 +254,6 @@
BoolOption("optimized_int_add",
"special case the addition of two integers in BINARY_ADD",
default=False),
- BoolOption("optimized_comparison_op",
- "special case the comparison of integers",
- default=False),
BoolOption("optimized_list_getitem",
"special case the 'list[integer]' expressions",
default=False),
@@ -307,7 +299,6 @@
# all the good optimizations for PyPy should be listed here
if level in ['2', '3', 'jit']:
- config.objspace.opcodes.suggest(CALL_METHOD=True)
config.objspace.std.suggest(withrangelist=True)
config.objspace.std.suggest(withmethodcache=True)
config.objspace.std.suggest(withprebuiltchar=True)
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
@@ -339,9 +339,10 @@
+ methods and other class attributes do not change after startup
+ single inheritance is fully supported
-+ simple mixins somewhat work too, but the mixed in class needs a
- ``_mixin_ = True`` class attribute. isinstance checks against the
- mixin type will fail when translated.
++ use `rpython.rlib.objectmodel.import_from_mixin(M)` in a class
+ body to copy the whole content of a class `M`. This can be used
+ to implement mixins: functions and staticmethods are duplicated
+ (the other class attributes are just copied unmodified).
+ classes are first-class objects too
diff --git a/pypy/doc/config/objspace.opcodes.CALL_METHOD.txt b/pypy/doc/config/objspace.opcodes.CALL_METHOD.txt
deleted file mode 100644
--- a/pypy/doc/config/objspace.opcodes.CALL_METHOD.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-Enable a pair of bytecodes that speed up method calls.
-See ``pypy.interpreter.callmethod`` for a description.
-
-The goal is to avoid creating the bound method object in the common
-case. So far, this only works for calls with no keyword, no ``*arg``
-and no ``**arg`` but it would be easy to extend.
-
-For more information, see the section in `Standard Interpreter Optimizations`_.
-
-.. _`Standard Interpreter Optimizations`: ../interpreter-optimizations.html#lookup-method-call-method
diff --git a/pypy/doc/config/objspace.opcodes.txt b/pypy/doc/config/objspace.opcodes.txt
deleted file mode 100644
--- a/pypy/doc/config/objspace.opcodes.txt
+++ /dev/null
@@ -1,1 +0,0 @@
-.. intentionally empty
diff --git a/pypy/doc/getting-started-python.rst b/pypy/doc/getting-started-python.rst
--- a/pypy/doc/getting-started-python.rst
+++ b/pypy/doc/getting-started-python.rst
@@ -57,6 +57,12 @@
zlib-devel bzip2-devel ncurses-devel expat-devel \
openssl-devel gc-devel python-sphinx python-greenlet
+ On SLES11:
+
+ $ sudo zypper install gcc make python-devel pkg-config \
+ zlib-devel libopenssl-devel libbz2-devel sqlite3-devel \
+ libexpat-devel libffi-devel python-curses
+
The above command lines are split with continuation characters, giving the necessary dependencies first, then the optional ones.
* ``pkg-config`` (to help us locate libffi files)
diff --git a/pypy/doc/interpreter-optimizations.rst b/pypy/doc/interpreter-optimizations.rst
--- a/pypy/doc/interpreter-optimizations.rst
+++ b/pypy/doc/interpreter-optimizations.rst
@@ -198,9 +198,6 @@
if it is not None, then it is considered to be an additional first
argument in the call to the *im_func* object from the stack.
-You can enable this feature with the :config:`objspace.opcodes.CALL_METHOD`
-option.
-
.. more here?
Overall Effects
diff --git a/pypy/doc/tool/makecontributor.py b/pypy/doc/tool/makecontributor.py
--- a/pypy/doc/tool/makecontributor.py
+++ b/pypy/doc/tool/makecontributor.py
@@ -60,6 +60,11 @@
'Roberto De Ioris': ['roberto at mrspurr'],
'Sven Hager': ['hager'],
'Tomo Cocoa': ['cocoatomo'],
+ 'Romain Guillebert': ['rguillebert', 'rguillbert', 'romain', 'Guillebert Romain'],
+ 'Ronan Lamy': ['ronan'],
+ 'Edd Barrett': ['edd'],
+ 'Manuel Jacob': ['mjacob'],
+ 'Rami Chowdhury': ['necaris'],
}
alias_map = {}
@@ -80,7 +85,8 @@
if not match:
return set()
ignore_words = ['around', 'consulting', 'yesterday', 'for a bit', 'thanks',
- 'in-progress', 'bits of', 'even a little', 'floating',]
+ 'in-progress', 'bits of', 'even a little', 'floating',
+ 'a bit', 'reviewing']
sep_words = ['and', ';', '+', '/', 'with special by']
nicknames = match.group(1)
for word in ignore_words:
@@ -119,7 +125,7 @@
## print '%5d %s' % (n, name)
## else:
## print name
-
+
items = authors_count.items()
items.sort(key=operator.itemgetter(1), reverse=True)
for name, n in items:
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,11 @@
.. this is a revision shortly after release-2.1-beta
.. startrev: 4eb52818e7c0
+.. branch: sanitise_bytecode_dispatch
+Make PyPy's bytecode dispatcher easy to read, and less reliant on RPython
+magic. There is no functional change, though the removal of dead code leads
+to many fewer tests to execute.
+
.. branch: fastjson
Fast json decoder written in RPython, about 3-4x faster than the pure Python
decoder which comes with the stdlib
@@ -74,3 +79,18 @@
.. branch: dotviewer-linewidth
.. branch: reflex-support
.. branch: numpypy-inplace-op
+.. branch: rewritten-loop-logging
+
+.. branch: nobold-backtrace
+Work on improving UnionError messages and stack trace displays.
+
+.. branch: improve-errors-again
+More improvements and refactorings of error messages.
+
+.. branch: improve-errors-again2
+Unbreak tests in rlib.
+
+.. branch: less-stringly-ops
+Use subclasses of SpaceOperation instead of SpaceOperator objects.
+Random cleanups in flowspace.
+
diff --git a/pypy/doc/windows.rst b/pypy/doc/windows.rst
--- a/pypy/doc/windows.rst
+++ b/pypy/doc/windows.rst
@@ -6,6 +6,10 @@
The following text gives some hints about how to translate the PyPy
interpreter.
+PyPy supports only being translated as a 32bit program, even on
+64bit Windows. See at the end of this page for what is missing
+for a full 64bit translation.
+
To build pypy-c you need a C compiler. Microsoft Visual Studio is
preferred, but can also use the mingw32 port of gcc.
@@ -63,7 +67,7 @@
INCLUDE, LIB and PATH (for DLLs) environment variables appropriately.
Abridged method (for -Ojit builds using Visual Studio 2008)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Download the versions of all the external packages
from
https://bitbucket.org/pypy/pypy/downloads/local.zip
@@ -112,13 +116,14 @@
nmake -f makefile.msc
The sqlite3 database library
-~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Download http://www.sqlite.org/2013/sqlite-amalgamation-3071601.zip and extract
it into a directory under the base directory. Also get
http://www.sqlite.org/2013/sqlite-dll-win32-x86-3071601.zip and extract the dll
into the bin directory, and the sqlite3.def into the sources directory.
Now build the import library so cffi can use the header and dll::
+
lib /DEF:sqlite3.def" /OUT:sqlite3.lib"
copy sqlite3.lib path\to\libs
@@ -206,8 +211,86 @@
March 2012, --cc is not a valid option for pytest.py. However if you set an
environment variable CC to the compliter exe, testing will use it.
-.. _'mingw32 build': http://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Automated%20Builds
+.. _`mingw32 build`: http://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Automated%20Builds
.. _`mingw64 build`: http://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Automated%20Builds
.. _`msys for mingw`: http://sourceforge.net/projects/mingw-w64/files/External%20binary%20packages%20%28Win64%20hosted%29/MSYS%20%2832-bit%29
.. _`libffi source files`: http://sourceware.org/libffi/
.. _`RPython translation toolchain`: translation.html
+
+
+What is missing for a full 64-bit translation
+---------------------------------------------
+
+The main blocker is that we assume that the integer type of RPython is
+large enough to (occasionally) contain a pointer value cast to an
+integer. The simplest fix is to make sure that it is so, but it will
+give the following incompatibility between CPython and PyPy on Win64:
+
+CPython: ``sys.maxint == 2**32-1, sys.maxsize == 2**64-1``
+
+PyPy: ``sys.maxint == sys.maxsize == 2**64-1``
+
+...and, correspondingly, PyPy supports ints up to the larger value of
+sys.maxint before they are converted to ``long``. The first decision
+that someone needs to make is if this incompatibility is reasonable.
+
+Assuming that it is, the first thing to do is probably to hack *CPython*
+until it fits this model: replace the field in PyIntObject with a ``long
+long`` field, and change the value of ``sys.maxint``. This might just
+work, even if half-brokenly: I'm sure you can crash it because of the
+precision loss that undoubtedly occurs everywhere, but try not to. :-)
+
+Such a hacked CPython is what you'll use in the next steps. We'll call
+it CPython64/64.
+
+It is probably not too much work if the goal is only to get a translated
+PyPy executable, and to run all tests before transaction. But you need
+to start somewhere, and you should start with some tests in
+rpython/translator/c/test/, like ``test_standalone.py`` and
+``test_newgc.py``: try to have them pass on top of CPython64/64.
+
+Keep in mind that this runs small translations, and some details may go
+wrong. The most obvious one is to check that it produces C files that
+use the integer type ``Signed`` --- but what is ``Signed`` defined to?
+It should be equal to ``long`` on every other platforms, but on Win64 it
+should be something like ``long long``.
+
+What is more generally needed is to review all the C files in
+rpython/translator/c/src for the word ``long``, because this means a
+32-bit integer even on Win64. Replace it with ``Signed`` most of the
+times. You can replace one with the other without breaking anything on
+any other platform, so feel free to.
+
+Then, these two C types have corresponding RPython types: ``rffi.LONG``
+and ``lltype.Signed`` respectively. The first should really correspond
+to the C ``long``. Add tests that check that integers casted to one
+type or the other really have 32 and 64 bits respectively, on Win64.
+
+Once these basic tests work, you need to review ``rpython/rlib/`` for
+usages of ``rffi.LONG`` versus ``lltype.Signed``. The goal would be to
+fix some more ``LONG-versus-Signed`` issues, by fixing the tests --- as
+always run on top of CPython64/64. Note that there was some early work
+done in ``rpython/rlib/rarithmetic`` with the goal of running all the
+tests on Win64 on the regular CPython, but I think by now that it's a
+bad idea. Look only at CPython64/64.
+
+The major intermediate goal is to get a translation of PyPy with ``-O2``
+with a minimal set of modules, starting with ``--no-allworkingmodules``;
+you need to use CPython64/64 to run this translation too. Check
+carefully the warnings of the C compiler at the end. I think that MSVC
+is "nice" in the sense that by default a lot of mismatches of integer
+sizes are reported as warnings.
+
+Then you need to review ``pypy/module/*/`` for ``LONG-versus-Signed``
+issues. At some time during this review, we get a working translated
+PyPy on Windows 64 that includes all ``--translationmodules``, i.e.
+everything needed to run translations. When we are there, the hacked
+CPython64/64 becomes much less important, because we can run future
+translations on top of this translated PyPy. As soon as we get there,
+please *distribute* the translated PyPy. It's an essential component
+for anyone else that wants to work on Win64! We end up with a strange
+kind of dependency --- we need a translated PyPy in order to translate a
+PyPy ---, but I believe it's ok here, as Windows executables are
+supposed to never be broken by newer versions of Windows.
+
+Happy hacking :-)
diff --git a/pypy/interpreter/app_main.py b/pypy/interpreter/app_main.py
--- a/pypy/interpreter/app_main.py
+++ b/pypy/interpreter/app_main.py
@@ -119,13 +119,12 @@
except:
try:
stderr = sys.stderr
- except AttributeError:
- pass # too bad
- else:
print >> stderr, 'Error calling sys.excepthook:'
originalexcepthook(*sys.exc_info())
print >> stderr
print >> stderr, 'Original exception was:'
+ except:
+ pass # too bad
# we only get here if sys.excepthook didn't do its job
originalexcepthook(etype, evalue, etraceback)
diff --git a/pypy/interpreter/astcompiler/codegen.py b/pypy/interpreter/astcompiler/codegen.py
--- a/pypy/interpreter/astcompiler/codegen.py
+++ b/pypy/interpreter/astcompiler/codegen.py
@@ -982,9 +982,8 @@
return self._call_has_no_star_args(call) and not call.keywords
def _optimize_method_call(self, call):
- if not self.space.config.objspace.opcodes.CALL_METHOD or \
- not self._call_has_no_star_args(call) or \
- not isinstance(call.func, ast.Attribute):
+ if not self._call_has_no_star_args(call) or \
+ not isinstance(call.func, ast.Attribute):
return False
attr_lookup = call.func
assert isinstance(attr_lookup, ast.Attribute)
diff --git a/pypy/interpreter/buffer.py b/pypy/interpreter/buffer.py
--- a/pypy/interpreter/buffer.py
+++ b/pypy/interpreter/buffer.py
@@ -19,7 +19,7 @@
from pypy.interpreter.typedef import TypeDef
from pypy.interpreter.gateway import interp2app, unwrap_spec
from pypy.interpreter.error import OperationError
-from rpython.rlib.objectmodel import compute_hash
+from rpython.rlib.objectmodel import compute_hash, import_from_mixin
from rpython.rlib.rstring import StringBuilder
@@ -272,8 +272,6 @@
# ____________________________________________________________
class SubBufferMixin(object):
- _mixin_ = True
-
def __init__(self, buffer, offset, size):
self.buffer = buffer
self.offset = offset
@@ -297,10 +295,11 @@
# out of bounds
return self.buffer.getslice(self.offset + start, self.offset + stop, step, size)
-class SubBuffer(SubBufferMixin, Buffer):
- pass
+class SubBuffer(Buffer):
+ import_from_mixin(SubBufferMixin)
-class RWSubBuffer(SubBufferMixin, RWBuffer):
+class RWSubBuffer(RWBuffer):
+ import_from_mixin(SubBufferMixin)
def setitem(self, index, char):
self.buffer.setitem(self.offset + index, char)
diff --git a/pypy/interpreter/pycode.py b/pypy/interpreter/pycode.py
--- a/pypy/interpreter/pycode.py
+++ b/pypy/interpreter/pycode.py
@@ -251,8 +251,10 @@
tuple(self.co_cellvars))
def exec_host_bytecode(self, w_globals, w_locals):
- from pypy.interpreter.pyframe import CPythonFrame
- frame = CPythonFrame(self.space, self, w_globals, None)
+ if sys.version_info < (2, 7):
+ raise Exception("PyPy no longer supports Python 2.6 or lower")
+ from pypy.interpreter.pyframe import PyFrame
+ frame = self.space.FrameClass(self.space, self, w_globals, None)
frame.setdictscope(w_locals)
return frame.run()
diff --git a/pypy/interpreter/pyframe.py b/pypy/interpreter/pyframe.py
--- a/pypy/interpreter/pyframe.py
+++ b/pypy/interpreter/pyframe.py
@@ -52,7 +52,7 @@
def __init__(self, space, code, w_globals, outer_func):
if not we_are_translated():
- assert type(self) in (space.FrameClass, CPythonFrame), (
+ assert type(self) == space.FrameClass, (
"use space.FrameClass(), not directly PyFrame()")
self = hint(self, access_directly=True, fresh_virtualizable=True)
assert isinstance(code, pycode.PyCode)
@@ -674,17 +674,6 @@
return space.wrap(self.builtin is not space.builtin)
return space.w_False
-class CPythonFrame(PyFrame):
- """
- Execution of host (CPython) opcodes.
- """
-
- bytecode_spec = host_bytecode_spec
- opcode_method_names = host_bytecode_spec.method_names
- opcodedesc = host_bytecode_spec.opcodedesc
- opdescmap = host_bytecode_spec.opdescmap
- HAVE_ARGUMENT = host_bytecode_spec.HAVE_ARGUMENT
-
# ____________________________________________________________
diff --git a/pypy/interpreter/pyopcode.py b/pypy/interpreter/pyopcode.py
--- a/pypy/interpreter/pyopcode.py
+++ b/pypy/interpreter/pyopcode.py
@@ -13,10 +13,8 @@
from rpython.rlib.objectmodel import we_are_translated
from rpython.rlib import jit, rstackovf
from rpython.rlib.rarithmetic import r_uint, intmask
-from rpython.rlib.unroll import unrolling_iterable
from rpython.rlib.debug import check_nonneg
-from pypy.tool.stdlib_opcode import (bytecode_spec,
- unrolling_all_opcode_descs)
+from pypy.tool.stdlib_opcode import bytecode_spec
def unaryoperation(operationname):
"""NOT_RPYTHON"""
@@ -41,34 +39,14 @@
return func_with_new_name(opimpl, "opcode_impl_for_%s" % operationname)
-compare_dispatch_table = [
- "cmp_lt", # "<"
- "cmp_le", # "<="
- "cmp_eq", # "=="
- "cmp_ne", # "!="
- "cmp_gt", # ">"
- "cmp_ge", # ">="
- "cmp_in",
- "cmp_not_in",
- "cmp_is",
- "cmp_is_not",
- "cmp_exc_match",
- ]
-unrolling_compare_dispatch_table = unrolling_iterable(
- enumerate(compare_dispatch_table))
-
+opcodedesc = bytecode_spec.opcodedesc
+HAVE_ARGUMENT = bytecode_spec.HAVE_ARGUMENT
class __extend__(pyframe.PyFrame):
"""A PyFrame that knows about interpretation of standard Python opcodes
minus the ones related to nested scopes."""
- bytecode_spec = bytecode_spec
- opcode_method_names = bytecode_spec.method_names
- opcodedesc = bytecode_spec.opcodedesc
- opdescmap = bytecode_spec.opdescmap
- HAVE_ARGUMENT = bytecode_spec.HAVE_ARGUMENT
-
### opcode dispatch ###
def dispatch(self, pycode, next_instr, ec):
@@ -170,7 +148,7 @@
opcode = ord(co_code[next_instr])
next_instr += 1
- if opcode >= self.HAVE_ARGUMENT:
+ if opcode >= HAVE_ARGUMENT:
lo = ord(co_code[next_instr])
hi = ord(co_code[next_instr+1])
next_instr += 2
@@ -180,19 +158,18 @@
# note: the structure of the code here is such that it makes
# (after translation) a big "if/elif" chain, which is then
- # turned into a switch(). It starts here: even if the first
- # one is not an "if" but a "while" the effect is the same.
+ # turned into a switch().
- while opcode == self.opcodedesc.EXTENDED_ARG.index:
+ while opcode == opcodedesc.EXTENDED_ARG.index:
opcode = ord(co_code[next_instr])
- if opcode < self.HAVE_ARGUMENT:
+ if opcode < HAVE_ARGUMENT:
raise BytecodeCorruption
lo = ord(co_code[next_instr+1])
hi = ord(co_code[next_instr+2])
next_instr += 3
oparg = (oparg * 65536) | (hi * 256) | lo
- if opcode == self.opcodedesc.RETURN_VALUE.index:
+ if opcode == opcodedesc.RETURN_VALUE.index:
w_returnvalue = self.popvalue()
block = self.unrollstack(SReturnValue.kind)
if block is None:
@@ -202,8 +179,7 @@
unroller = SReturnValue(w_returnvalue)
next_instr = block.handle(self, unroller)
return next_instr # now inside a 'finally' block
-
- if opcode == self.opcodedesc.END_FINALLY.index:
+ elif opcode == opcodedesc.END_FINALLY.index:
unroller = self.end_finally()
if isinstance(unroller, SuspendedUnroller):
# go on unrolling the stack
@@ -215,49 +191,248 @@
else:
next_instr = block.handle(self, unroller)
return next_instr
-
- if opcode == self.opcodedesc.JUMP_ABSOLUTE.index:
+ elif opcode == opcodedesc.JUMP_ABSOLUTE.index:
return self.jump_absolute(oparg, ec)
-
- if we_are_translated():
- for opdesc in unrolling_all_opcode_descs:
- # static checks to skip this whole case if necessary
- if opdesc.bytecode_spec is not self.bytecode_spec:
- continue
- if not opdesc.is_enabled(space):
- continue
- if opdesc.methodname in (
- 'EXTENDED_ARG', 'RETURN_VALUE',
- 'END_FINALLY', 'JUMP_ABSOLUTE'):
- continue # opcodes implemented above
-
- # the following "if" is part of the big switch described
- # above.
- if opcode == opdesc.index:
- # dispatch to the opcode method
- meth = getattr(self, opdesc.methodname)
- res = meth(oparg, next_instr)
- # !! warning, for the annotator the next line is not
- # comparing an int and None - you can't do that.
- # Instead, it's constant-folded to either True or False
- if res is not None:
- next_instr = res
- break
- else:
- self.MISSING_OPCODE(oparg, next_instr)
-
- else: # when we are not translated, a list lookup is much faster
- methodname = self.opcode_method_names[opcode]
- try:
- meth = getattr(self, methodname)
- except AttributeError:
- raise BytecodeCorruption("unimplemented opcode, ofs=%d, "
- "code=%d, name=%s" %
- (self.last_instr, opcode,
- methodname))
- res = meth(oparg, next_instr)
- if res is not None:
- next_instr = res
+ elif opcode == opcodedesc.BREAK_LOOP.index:
+ next_instr = self.BREAK_LOOP(oparg, next_instr)
+ elif opcode == opcodedesc.CONTINUE_LOOP.index:
+ next_instr = self.CONTINUE_LOOP(oparg, next_instr)
+ elif opcode == opcodedesc.FOR_ITER.index:
+ next_instr = self.FOR_ITER(oparg, next_instr)
+ elif opcode == opcodedesc.JUMP_FORWARD.index:
+ next_instr = self.JUMP_FORWARD(oparg, next_instr)
+ elif opcode == opcodedesc.JUMP_IF_FALSE_OR_POP.index:
+ next_instr = self.JUMP_IF_FALSE_OR_POP(oparg, next_instr)
+ elif opcode == opcodedesc.JUMP_IF_NOT_DEBUG.index:
+ next_instr = self.JUMP_IF_NOT_DEBUG(oparg, next_instr)
+ elif opcode == opcodedesc.JUMP_IF_TRUE_OR_POP.index:
+ next_instr = self.JUMP_IF_TRUE_OR_POP(oparg, next_instr)
+ elif opcode == opcodedesc.POP_JUMP_IF_FALSE.index:
+ next_instr = self.POP_JUMP_IF_FALSE(oparg, next_instr)
+ elif opcode == opcodedesc.POP_JUMP_IF_TRUE.index:
+ next_instr = self.POP_JUMP_IF_TRUE(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_ADD.index:
+ self.BINARY_ADD(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_AND.index:
+ self.BINARY_AND(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_DIVIDE.index:
+ self.BINARY_DIVIDE(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_FLOOR_DIVIDE.index:
+ self.BINARY_FLOOR_DIVIDE(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_LSHIFT.index:
+ self.BINARY_LSHIFT(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_MODULO.index:
+ self.BINARY_MODULO(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_MULTIPLY.index:
+ self.BINARY_MULTIPLY(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_OR.index:
+ self.BINARY_OR(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_POWER.index:
+ self.BINARY_POWER(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_RSHIFT.index:
+ self.BINARY_RSHIFT(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_SUBSCR.index:
+ self.BINARY_SUBSCR(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_SUBTRACT.index:
+ self.BINARY_SUBTRACT(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_TRUE_DIVIDE.index:
+ self.BINARY_TRUE_DIVIDE(oparg, next_instr)
+ elif opcode == opcodedesc.BINARY_XOR.index:
+ self.BINARY_XOR(oparg, next_instr)
+ elif opcode == opcodedesc.BUILD_CLASS.index:
+ self.BUILD_CLASS(oparg, next_instr)
+ elif opcode == opcodedesc.BUILD_LIST.index:
+ self.BUILD_LIST(oparg, next_instr)
+ elif opcode == opcodedesc.BUILD_LIST_FROM_ARG.index:
+ self.BUILD_LIST_FROM_ARG(oparg, next_instr)
+ elif opcode == opcodedesc.BUILD_MAP.index:
+ self.BUILD_MAP(oparg, next_instr)
+ elif opcode == opcodedesc.BUILD_SET.index:
+ self.BUILD_SET(oparg, next_instr)
+ elif opcode == opcodedesc.BUILD_SLICE.index:
+ self.BUILD_SLICE(oparg, next_instr)
+ elif opcode == opcodedesc.BUILD_TUPLE.index:
+ self.BUILD_TUPLE(oparg, next_instr)
+ elif opcode == opcodedesc.CALL_FUNCTION.index:
+ self.CALL_FUNCTION(oparg, next_instr)
+ elif opcode == opcodedesc.CALL_FUNCTION_KW.index:
+ self.CALL_FUNCTION_KW(oparg, next_instr)
+ elif opcode == opcodedesc.CALL_FUNCTION_VAR.index:
+ self.CALL_FUNCTION_VAR(oparg, next_instr)
+ elif opcode == opcodedesc.CALL_FUNCTION_VAR_KW.index:
+ self.CALL_FUNCTION_VAR_KW(oparg, next_instr)
+ elif opcode == opcodedesc.CALL_METHOD.index:
+ self.CALL_METHOD(oparg, next_instr)
+ elif opcode == opcodedesc.COMPARE_OP.index:
+ self.COMPARE_OP(oparg, next_instr)
+ elif opcode == opcodedesc.DELETE_ATTR.index:
+ self.DELETE_ATTR(oparg, next_instr)
+ elif opcode == opcodedesc.DELETE_FAST.index:
+ self.DELETE_FAST(oparg, next_instr)
+ elif opcode == opcodedesc.DELETE_GLOBAL.index:
+ self.DELETE_GLOBAL(oparg, next_instr)
+ elif opcode == opcodedesc.DELETE_NAME.index:
+ self.DELETE_NAME(oparg, next_instr)
+ elif opcode == opcodedesc.DELETE_SLICE_0.index:
+ self.DELETE_SLICE_0(oparg, next_instr)
+ elif opcode == opcodedesc.DELETE_SLICE_1.index:
+ self.DELETE_SLICE_1(oparg, next_instr)
+ elif opcode == opcodedesc.DELETE_SLICE_2.index:
+ self.DELETE_SLICE_2(oparg, next_instr)
+ elif opcode == opcodedesc.DELETE_SLICE_3.index:
+ self.DELETE_SLICE_3(oparg, next_instr)
+ elif opcode == opcodedesc.DELETE_SUBSCR.index:
+ self.DELETE_SUBSCR(oparg, next_instr)
+ elif opcode == opcodedesc.DUP_TOP.index:
+ self.DUP_TOP(oparg, next_instr)
+ elif opcode == opcodedesc.DUP_TOPX.index:
+ self.DUP_TOPX(oparg, next_instr)
+ elif opcode == opcodedesc.EXEC_STMT.index:
+ self.EXEC_STMT(oparg, next_instr)
+ elif opcode == opcodedesc.GET_ITER.index:
+ self.GET_ITER(oparg, next_instr)
+ elif opcode == opcodedesc.IMPORT_FROM.index:
+ self.IMPORT_FROM(oparg, next_instr)
+ elif opcode == opcodedesc.IMPORT_NAME.index:
+ self.IMPORT_NAME(oparg, next_instr)
+ elif opcode == opcodedesc.IMPORT_STAR.index:
+ self.IMPORT_STAR(oparg, next_instr)
+ elif opcode == opcodedesc.INPLACE_ADD.index:
+ self.INPLACE_ADD(oparg, next_instr)
+ elif opcode == opcodedesc.INPLACE_AND.index:
+ self.INPLACE_AND(oparg, next_instr)
+ elif opcode == opcodedesc.INPLACE_DIVIDE.index:
+ self.INPLACE_DIVIDE(oparg, next_instr)
+ elif opcode == opcodedesc.INPLACE_FLOOR_DIVIDE.index:
+ self.INPLACE_FLOOR_DIVIDE(oparg, next_instr)
+ elif opcode == opcodedesc.INPLACE_LSHIFT.index:
+ self.INPLACE_LSHIFT(oparg, next_instr)
+ elif opcode == opcodedesc.INPLACE_MODULO.index:
+ self.INPLACE_MODULO(oparg, next_instr)
+ elif opcode == opcodedesc.INPLACE_MULTIPLY.index:
+ self.INPLACE_MULTIPLY(oparg, next_instr)
+ elif opcode == opcodedesc.INPLACE_OR.index:
+ self.INPLACE_OR(oparg, next_instr)
+ elif opcode == opcodedesc.INPLACE_POWER.index:
+ self.INPLACE_POWER(oparg, next_instr)
+ elif opcode == opcodedesc.INPLACE_RSHIFT.index:
+ self.INPLACE_RSHIFT(oparg, next_instr)
+ elif opcode == opcodedesc.INPLACE_SUBTRACT.index:
+ self.INPLACE_SUBTRACT(oparg, next_instr)
+ elif opcode == opcodedesc.INPLACE_TRUE_DIVIDE.index:
+ self.INPLACE_TRUE_DIVIDE(oparg, next_instr)
+ elif opcode == opcodedesc.INPLACE_XOR.index:
+ self.INPLACE_XOR(oparg, next_instr)
+ elif opcode == opcodedesc.LIST_APPEND.index:
+ self.LIST_APPEND(oparg, next_instr)
+ elif opcode == opcodedesc.LOAD_ATTR.index:
+ self.LOAD_ATTR(oparg, next_instr)
+ elif opcode == opcodedesc.LOAD_CLOSURE.index:
+ self.LOAD_CLOSURE(oparg, next_instr)
+ elif opcode == opcodedesc.LOAD_CONST.index:
+ self.LOAD_CONST(oparg, next_instr)
+ elif opcode == opcodedesc.LOAD_DEREF.index:
+ self.LOAD_DEREF(oparg, next_instr)
+ elif opcode == opcodedesc.LOAD_FAST.index:
+ self.LOAD_FAST(oparg, next_instr)
+ elif opcode == opcodedesc.LOAD_GLOBAL.index:
+ self.LOAD_GLOBAL(oparg, next_instr)
+ elif opcode == opcodedesc.LOAD_LOCALS.index:
+ self.LOAD_LOCALS(oparg, next_instr)
+ elif opcode == opcodedesc.LOAD_NAME.index:
+ self.LOAD_NAME(oparg, next_instr)
+ elif opcode == opcodedesc.LOOKUP_METHOD.index:
+ self.LOOKUP_METHOD(oparg, next_instr)
+ elif opcode == opcodedesc.MAKE_CLOSURE.index:
+ self.MAKE_CLOSURE(oparg, next_instr)
+ elif opcode == opcodedesc.MAKE_FUNCTION.index:
+ self.MAKE_FUNCTION(oparg, next_instr)
+ elif opcode == opcodedesc.MAP_ADD.index:
+ self.MAP_ADD(oparg, next_instr)
+ elif opcode == opcodedesc.NOP.index:
+ self.NOP(oparg, next_instr)
+ elif opcode == opcodedesc.POP_BLOCK.index:
+ self.POP_BLOCK(oparg, next_instr)
+ elif opcode == opcodedesc.POP_TOP.index:
+ self.POP_TOP(oparg, next_instr)
+ elif opcode == opcodedesc.PRINT_EXPR.index:
+ self.PRINT_EXPR(oparg, next_instr)
+ elif opcode == opcodedesc.PRINT_ITEM.index:
+ self.PRINT_ITEM(oparg, next_instr)
+ elif opcode == opcodedesc.PRINT_ITEM_TO.index:
+ self.PRINT_ITEM_TO(oparg, next_instr)
+ elif opcode == opcodedesc.PRINT_NEWLINE.index:
+ self.PRINT_NEWLINE(oparg, next_instr)
+ elif opcode == opcodedesc.PRINT_NEWLINE_TO.index:
+ self.PRINT_NEWLINE_TO(oparg, next_instr)
+ elif opcode == opcodedesc.RAISE_VARARGS.index:
+ self.RAISE_VARARGS(oparg, next_instr)
+ elif opcode == opcodedesc.ROT_FOUR.index:
+ self.ROT_FOUR(oparg, next_instr)
+ elif opcode == opcodedesc.ROT_THREE.index:
+ self.ROT_THREE(oparg, next_instr)
+ elif opcode == opcodedesc.ROT_TWO.index:
+ self.ROT_TWO(oparg, next_instr)
+ elif opcode == opcodedesc.SETUP_EXCEPT.index:
+ self.SETUP_EXCEPT(oparg, next_instr)
+ elif opcode == opcodedesc.SETUP_FINALLY.index:
+ self.SETUP_FINALLY(oparg, next_instr)
+ elif opcode == opcodedesc.SETUP_LOOP.index:
+ self.SETUP_LOOP(oparg, next_instr)
+ elif opcode == opcodedesc.SETUP_WITH.index:
+ self.SETUP_WITH(oparg, next_instr)
+ elif opcode == opcodedesc.SET_ADD.index:
+ self.SET_ADD(oparg, next_instr)
+ elif opcode == opcodedesc.SLICE_0.index:
+ self.SLICE_0(oparg, next_instr)
+ elif opcode == opcodedesc.SLICE_1.index:
+ self.SLICE_1(oparg, next_instr)
+ elif opcode == opcodedesc.SLICE_2.index:
+ self.SLICE_2(oparg, next_instr)
+ elif opcode == opcodedesc.SLICE_3.index:
+ self.SLICE_3(oparg, next_instr)
+ elif opcode == opcodedesc.STOP_CODE.index:
+ self.STOP_CODE(oparg, next_instr)
+ elif opcode == opcodedesc.STORE_ATTR.index:
+ self.STORE_ATTR(oparg, next_instr)
+ elif opcode == opcodedesc.STORE_DEREF.index:
+ self.STORE_DEREF(oparg, next_instr)
+ elif opcode == opcodedesc.STORE_FAST.index:
+ self.STORE_FAST(oparg, next_instr)
+ elif opcode == opcodedesc.STORE_GLOBAL.index:
+ self.STORE_GLOBAL(oparg, next_instr)
+ elif opcode == opcodedesc.STORE_MAP.index:
+ self.STORE_MAP(oparg, next_instr)
+ elif opcode == opcodedesc.STORE_NAME.index:
+ self.STORE_NAME(oparg, next_instr)
+ elif opcode == opcodedesc.STORE_SLICE_0.index:
+ self.STORE_SLICE_0(oparg, next_instr)
+ elif opcode == opcodedesc.STORE_SLICE_1.index:
+ self.STORE_SLICE_1(oparg, next_instr)
+ elif opcode == opcodedesc.STORE_SLICE_2.index:
+ self.STORE_SLICE_2(oparg, next_instr)
+ elif opcode == opcodedesc.STORE_SLICE_3.index:
+ self.STORE_SLICE_3(oparg, next_instr)
+ elif opcode == opcodedesc.STORE_SUBSCR.index:
+ self.STORE_SUBSCR(oparg, next_instr)
+ elif opcode == opcodedesc.UNARY_CONVERT.index:
+ self.UNARY_CONVERT(oparg, next_instr)
+ elif opcode == opcodedesc.UNARY_INVERT.index:
+ self.UNARY_INVERT(oparg, next_instr)
+ elif opcode == opcodedesc.UNARY_NEGATIVE.index:
+ self.UNARY_NEGATIVE(oparg, next_instr)
+ elif opcode == opcodedesc.UNARY_NOT.index:
+ self.UNARY_NOT(oparg, next_instr)
+ elif opcode == opcodedesc.UNARY_POSITIVE.index:
+ self.UNARY_POSITIVE(oparg, next_instr)
+ elif opcode == opcodedesc.UNPACK_SEQUENCE.index:
+ self.UNPACK_SEQUENCE(oparg, next_instr)
+ elif opcode == opcodedesc.WITH_CLEANUP.index:
+ self.WITH_CLEANUP(oparg, next_instr)
+ elif opcode == opcodedesc.YIELD_VALUE.index:
+ self.YIELD_VALUE(oparg, next_instr)
+ else:
+ self.MISSING_OPCODE(oparg, next_instr)
if jit.we_are_jitted():
return next_instr
@@ -733,36 +908,6 @@
self.pushvalue(w_value)
LOAD_ATTR._always_inline_ = True
- def cmp_lt(self, w_1, w_2):
- return self.space.lt(w_1, w_2)
-
- def cmp_le(self, w_1, w_2):
- return self.space.le(w_1, w_2)
-
- def cmp_eq(self, w_1, w_2):
- return self.space.eq(w_1, w_2)
-
- def cmp_ne(self, w_1, w_2):
- return self.space.ne(w_1, w_2)
-
- def cmp_gt(self, w_1, w_2):
- return self.space.gt(w_1, w_2)
-
- def cmp_ge(self, w_1, w_2):
- return self.space.ge(w_1, w_2)
-
- def cmp_in(self, w_1, w_2):
- return self.space.contains(w_2, w_1)
-
- def cmp_not_in(self, w_1, w_2):
- return self.space.not_(self.space.contains(w_2, w_1))
-
- def cmp_is(self, w_1, w_2):
- return self.space.is_(w_1, w_2)
-
- def cmp_is_not(self, w_1, w_2):
- return self.space.not_(self.space.is_(w_1, w_2))
-
@jit.unroll_safe
def cmp_exc_match(self, w_1, w_2):
space = self.space
@@ -779,11 +924,28 @@
def COMPARE_OP(self, testnum, next_instr):
w_2 = self.popvalue()
w_1 = self.popvalue()
- w_result = None
- for i, attr in unrolling_compare_dispatch_table:
- if i == testnum:
- w_result = getattr(self, attr)(w_1, w_2)
- break
+ if testnum == 0:
+ w_result = self.space.lt(w_1, w_2)
+ elif testnum == 1:
+ w_result = self.space.le(w_1, w_2)
+ elif testnum == 2:
+ w_result = self.space.eq(w_1, w_2)
+ elif testnum == 3:
+ w_result = self.space.ne(w_1, w_2)
+ elif testnum == 4:
+ w_result = self.space.gt(w_1, w_2)
+ elif testnum == 5:
+ w_result = self.space.ge(w_1, w_2)
+ elif testnum == 6:
+ w_result = self.space.contains(w_2, w_1)
+ elif testnum == 7:
+ w_result = self.space.not_(self.space.contains(w_2, w_1))
+ elif testnum == 8:
+ w_result = self.space.is_(w_1, w_2)
+ elif testnum == 9:
+ w_result = self.space.not_(self.space.is_(w_1, w_2))
+ elif testnum == 10:
+ w_result = self.cmp_exc_match(w_1, w_2)
else:
raise BytecodeCorruption("bad COMPARE_OP oparg")
self.pushvalue(w_result)
@@ -1086,49 +1248,6 @@
self.space.setitem(w_dict, w_key, w_value)
-class __extend__(pyframe.CPythonFrame):
-
- def JUMP_IF_FALSE(self, stepby, next_instr):
- w_cond = self.peekvalue()
- if not self.space.is_true(w_cond):
- next_instr += stepby
- return next_instr
-
- def JUMP_IF_TRUE(self, stepby, next_instr):
- w_cond = self.peekvalue()
- if self.space.is_true(w_cond):
- next_instr += stepby
- return next_instr
-
- def BUILD_MAP(self, itemcount, next_instr):
- if sys.version_info >= (2, 6):
- # We could pre-allocate a dict here
- # but for the moment this code is not translated.
- pass
- else:
- if itemcount != 0:
- raise BytecodeCorruption
- w_dict = self.space.newdict()
- self.pushvalue(w_dict)
-
- def STORE_MAP(self, zero, next_instr):
- if sys.version_info >= (2, 6):
- w_key = self.popvalue()
- w_value = self.popvalue()
- w_dict = self.peekvalue()
- self.space.setitem(w_dict, w_key, w_value)
- else:
- raise BytecodeCorruption
-
- def LIST_APPEND(self, oparg, next_instr):
- w = self.popvalue()
- if sys.version_info < (2, 7):
- v = self.popvalue()
- else:
- v = self.peekvalue(oparg - 1)
- self.space.call_method(v, 'append', w)
-
-
### ____________________________________________________________ ###
class ExitFrame(Exception):
diff --git a/pypy/interpreter/test/test_compiler.py b/pypy/interpreter/test/test_compiler.py
--- a/pypy/interpreter/test/test_compiler.py
+++ b/pypy/interpreter/test/test_compiler.py
@@ -953,10 +953,6 @@
assert i > -1
assert isinstance(co.co_consts[i], frozenset)
-
-class AppTestCallMethod(object):
- spaceconfig = {'objspace.opcodes.CALL_METHOD': True}
-
def test_call_method_kwargs(self):
source = """def _f(a):
return a.f(a=a)
diff --git a/pypy/interpreter/test/test_executioncontext.py b/pypy/interpreter/test/test_executioncontext.py
--- a/pypy/interpreter/test/test_executioncontext.py
+++ b/pypy/interpreter/test/test_executioncontext.py
@@ -253,10 +253,6 @@
""")
-class TestExecutionContextWithCallMethod(TestExecutionContext):
- spaceconfig ={'objspace.opcodes.CALL_METHOD': True}
-
-
class AppTestDelNotBlocked:
def setup_method(self, meth):
diff --git a/pypy/interpreter/test/test_gateway.py b/pypy/interpreter/test/test_gateway.py
--- a/pypy/interpreter/test/test_gateway.py
+++ b/pypy/interpreter/test/test_gateway.py
@@ -812,10 +812,6 @@
assert len(called) == 1
assert isinstance(called[0], argument.Arguments)
-class TestPassThroughArguments_CALL_METHOD(TestPassThroughArguments):
- spaceconfig = dict(usemodules=('itertools',), **{
- "objspace.opcodes.CALL_METHOD": True
- })
class AppTestKeywordsToBuiltinSanity(object):
diff --git a/pypy/module/__pypy__/test/test_signal.py b/pypy/module/__pypy__/test/test_signal.py
--- a/pypy/module/__pypy__/test/test_signal.py
+++ b/pypy/module/__pypy__/test/test_signal.py
@@ -34,7 +34,7 @@
thread.interrupt_main()
for i in range(10):
print('x')
- time.sleep(0.1)
+ time.sleep(0.25)
except BaseException, e:
interrupted.append(e)
finally:
@@ -59,7 +59,7 @@
for j in range(10):
if len(done): break
print('.')
- time.sleep(0.1)
+ time.sleep(0.25)
print('main thread loop done')
assert len(done) == 1
assert len(interrupted) == 1
@@ -117,7 +117,7 @@
def subthread():
try:
- time.sleep(0.25)
+ time.sleep(0.5)
with __pypy__.thread.signals_enabled:
thread.interrupt_main()
except BaseException, e:
diff --git a/pypy/module/_cffi_backend/test/_backend_test_c.py b/pypy/module/_cffi_backend/test/_backend_test_c.py
--- a/pypy/module/_cffi_backend/test/_backend_test_c.py
+++ b/pypy/module/_cffi_backend/test/_backend_test_c.py
@@ -1516,13 +1516,18 @@
d = BStruct.fields
assert d[0][1].offset == d[1][1].offset == d[2][1].offset == 0
assert d[3][1].offset == sizeof(BLong)
- assert d[0][1].bitshift == 0
+ def f(m, r):
+ if sys.byteorder == 'little':
+ return r
+ else:
+ return LONGBITS - m - r
+ assert d[0][1].bitshift == f(1, 0)
assert d[0][1].bitsize == 1
- assert d[1][1].bitshift == 1
+ assert d[1][1].bitshift == f(2, 1)
assert d[1][1].bitsize == 2
- assert d[2][1].bitshift == 3
+ assert d[2][1].bitshift == f(3, 3)
assert d[2][1].bitsize == 3
- assert d[3][1].bitshift == 0
+ assert d[3][1].bitshift == f(LONGBITS - 5, 0)
assert d[3][1].bitsize == LONGBITS - 5
assert sizeof(BStruct) == 2 * sizeof(BLong)
assert alignof(BStruct) == alignof(BLong)
@@ -2856,7 +2861,7 @@
('b1', BInt, 9),
('b2', BUInt, 7),
('c', BChar, -1)], -1, -1, -1, flag)
- if flag % 2 == 0: # gcc and gcc ARM
+ if flag % 2 == 0: # gcc, any variant
assert typeoffsetof(BStruct, 'c') == (BChar, 3)
assert sizeof(BStruct) == 4
else: # msvc
@@ -2864,6 +2869,31 @@
assert sizeof(BStruct) == 12
assert alignof(BStruct) == 4
#
+ p = newp(new_pointer_type(BStruct), None)
+ p.a = b'A'
+ p.b1 = -201
+ p.b2 = 99
+ p.c = b'\x9D'
+ raw = buffer(p)[:]
+ if sys.byteorder == 'little':
+ if flag == 0 or flag == 2: # gcc, little endian
+ assert raw == b'A7\xC7\x9D'
+ elif flag == 1: # msvc
+ assert raw == b'A\x00\x00\x007\xC7\x00\x00\x9D\x00\x00\x00'
+ elif flag == 4: # gcc, big endian
+ assert raw == b'A\xE3\x9B\x9D'
+ else:
+ raise AssertionError("bad flag")
+ else:
+ if flag == 0 or flag == 2: # gcc
+ assert raw == b'A\xC77\x9D'
+ elif flag == 1: # msvc
+ assert raw == b'A\x00\x00\x00\x00\x00\xC77\x9D\x00\x00\x00'
+ elif flag == 4: # gcc, big endian
+ assert raw == b'A\x9B\xE3\x9D'
+ else:
+ raise AssertionError("bad flag")
+ #
BStruct = new_struct_type("struct foo2")
complete_struct_or_union(BStruct, [('a', BChar, -1),
('', BShort, 9),
@@ -2875,16 +2905,21 @@
elif flag == 1: # msvc
assert sizeof(BStruct) == 6
assert alignof(BStruct) == 2
- else: # gcc ARM
+ elif flag == 2: # gcc ARM
assert sizeof(BStruct) == 6
assert alignof(BStruct) == 2
+ elif flag == 4: # gcc, big endian
+ assert sizeof(BStruct) == 5
+ assert alignof(BStruct) == 1
+ else:
+ raise AssertionError("bad flag")
#
BStruct = new_struct_type("struct foo2")
complete_struct_or_union(BStruct, [('a', BChar, -1),
('', BInt, 0),
('', BInt, 0),
('c', BChar, -1)], -1, -1, -1, flag)
- if flag == 0: # gcc
+ if flag == 0: # gcc
assert typeoffsetof(BStruct, 'c') == (BChar, 4)
assert sizeof(BStruct) == 5
assert alignof(BStruct) == 1
@@ -2892,10 +2927,16 @@
assert typeoffsetof(BStruct, 'c') == (BChar, 1)
assert sizeof(BStruct) == 2
assert alignof(BStruct) == 1
- else: # gcc ARM
+ elif flag == 2: # gcc ARM
assert typeoffsetof(BStruct, 'c') == (BChar, 4)
assert sizeof(BStruct) == 8
assert alignof(BStruct) == 4
+ elif flag == 4: # gcc, big endian
+ assert typeoffsetof(BStruct, 'c') == (BChar, 4)
+ assert sizeof(BStruct) == 5
+ assert alignof(BStruct) == 1
+ else:
+ raise AssertionError("bad flag")
def test_bitfield_as_gcc():
@@ -2907,6 +2948,11 @@
def test_bitfield_as_arm_gcc():
_test_bitfield_details(flag=2)
+def test_bitfield_as_big_endian():
+ if '__pypy__' in sys.builtin_module_names:
+ py.test.skip("no big endian machine supported on pypy for now")
+ _test_bitfield_details(flag=4)
+
def test_version():
# this test is here mostly for PyPy
diff --git a/pypy/module/_continuation/interp_pickle.py b/pypy/module/_continuation/interp_pickle.py
--- a/pypy/module/_continuation/interp_pickle.py
+++ b/pypy/module/_continuation/interp_pickle.py
@@ -120,8 +120,7 @@
nkwds = (oparg >> 8) & 0xff
if nkwds == 0: # only positional arguments
# fast paths leaves things on the stack, pop them
- if (frame.space.config.objspace.opcodes.CALL_METHOD and
- opcode == map['CALL_METHOD']):
+ if opcode == map['CALL_METHOD']:
frame.dropvalues(nargs + 2)
elif opcode == map['CALL_FUNCTION']:
frame.dropvalues(nargs + 1)
diff --git a/pypy/module/_continuation/test/test_zpickle.py b/pypy/module/_continuation/test/test_zpickle.py
--- a/pypy/module/_continuation/test/test_zpickle.py
+++ b/pypy/module/_continuation/test/test_zpickle.py
@@ -1,8 +1,7 @@
class AppTestCopy:
spaceconfig = dict(usemodules=['_continuation'],
- continuation=True,
- CALL_METHOD=True)
+ continuation=True)
def test_basic_setup(self):
from _continuation import continulet
@@ -104,7 +103,6 @@
spaceconfig = {
"usemodules": ['_continuation', 'struct', 'binascii'],
"continuation": True,
- "CALL_METHOD": True,
}
def setup_class(cls):
diff --git a/pypy/module/_file/interp_file.py b/pypy/module/_file/interp_file.py
--- a/pypy/module/_file/interp_file.py
+++ b/pypy/module/_file/interp_file.py
@@ -437,14 +437,14 @@
return self.getrepr(self.space, info)
def getdisplayname(self):
+ space = self.space
w_name = self.w_name
if w_name is None:
return '?'
- elif self.space.is_true(self.space.isinstance(w_name,
- self.space.w_str)):
- return "'%s'" % self.space.str_w(w_name)
+ elif space.isinstance_w(w_name, space.w_str):
+ return "'%s'" % space.str_w(w_name)
else:
- return self.space.str_w(self.space.repr(w_name))
+ return space.str_w(space.repr(w_name))
def file_writelines(self, w_lines):
"""writelines(sequence_of_strings) -> None. Write the strings to the file.
diff --git a/pypy/module/_lsprof/test/test_cprofile.py b/pypy/module/_lsprof/test/test_cprofile.py
--- a/pypy/module/_lsprof/test/test_cprofile.py
+++ b/pypy/module/_lsprof/test/test_cprofile.py
@@ -191,11 +191,6 @@
sys.path.pop(0)
-class AppTestWithDifferentBytecodes(AppTestCProfile):
- spaceconfig = AppTestCProfile.spaceconfig.copy()
- spaceconfig['objspace.opcodes.CALL_METHOD'] = True
-
-
expected_output = {}
expected_output['print_stats'] = """\
126 function calls (106 primitive calls) in 1.000 seconds
diff --git a/pypy/module/array/interp_array.py b/pypy/module/array/interp_array.py
--- a/pypy/module/array/interp_array.py
+++ b/pypy/module/array/interp_array.py
@@ -11,7 +11,7 @@
from rpython.rlib.unroll import unrolling_iterable
from rpython.rlib.objectmodel import keepalive_until_here
from rpython.rtyper.lltypesystem import lltype, rffi
-
+from pypy.objspace.std.floatobject import W_FloatObject
@unwrap_spec(typecode=str)
def w_array(space, w_cls, typecode, __args__):
@@ -532,7 +532,7 @@
class TypeCode(object):
- def __init__(self, itemtype, unwrap, canoverflow=False, signed=False):
+ def __init__(self, itemtype, unwrap, canoverflow=False, signed=False, method='__int__'):
self.itemtype = itemtype
self.bytes = rffi.sizeof(itemtype)
self.arraytype = lltype.Array(itemtype, hints={'nolength': True})
@@ -540,6 +540,7 @@
self.signed = signed
self.canoverflow = canoverflow
self.w_class = None
+ self.method = method
if self.canoverflow:
assert self.bytes <= rffi.sizeof(rffi.ULONG)
@@ -554,8 +555,8 @@
return True
types = {
- 'c': TypeCode(lltype.Char, 'str_w'),
- 'u': TypeCode(lltype.UniChar, 'unicode_w'),
+ 'c': TypeCode(lltype.Char, 'str_w', method=''),
+ 'u': TypeCode(lltype.UniChar, 'unicode_w', method=''),
'b': TypeCode(rffi.SIGNEDCHAR, 'int_w', True, True),
'B': TypeCode(rffi.UCHAR, 'int_w', True),
'h': TypeCode(rffi.SHORT, 'int_w', True, True),
@@ -567,8 +568,8 @@
# rbigint.touint() which
# corresponds to the
# C-type unsigned long
- 'f': TypeCode(lltype.SingleFloat, 'float_w'),
- 'd': TypeCode(lltype.Float, 'float_w'),
+ 'f': TypeCode(lltype.SingleFloat, 'float_w', method='__float__'),
+ 'd': TypeCode(lltype.Float, 'float_w', method='__float__'),
}
for k, v in types.items():
v.typecode = k
@@ -613,7 +614,19 @@
def item_w(self, w_item):
space = self.space
unwrap = getattr(space, mytype.unwrap)
- item = unwrap(w_item)
+ try:
+ item = unwrap(w_item)
+ except OperationError, e:
+ if isinstance(w_item, W_FloatObject): # Odd special case from cpython
+ raise
+ if mytype.method != '' and e.match(space, space.w_TypeError):
+ try:
+ item = unwrap(space.call_method(w_item, mytype.method))
+ except OperationError:
+ msg = 'array item must be ' + mytype.unwrap[:-2]
+ raise OperationError(space.w_TypeError, space.wrap(msg))
+ else:
+ raise
if mytype.unwrap == 'bigint_w':
try:
item = item.touint()
diff --git a/pypy/module/array/test/test_array.py b/pypy/module/array/test/test_array.py
--- a/pypy/module/array/test/test_array.py
+++ b/pypy/module/array/test/test_array.py
@@ -874,6 +874,77 @@
assert l
assert l[0] is None or len(l[0]) == 0
+ def test_assign_object_with_special_methods(self):
+ from array import array
+
+ class Num(object):
+ def __float__(self):
+ return 5.25
+
+ def __int__(self):
+ return 7
+
+ class NotNum(object):
+ pass
+
+ class Silly(object):
+ def __float__(self):
+ return None
+
+ def __int__(self):
+ return None
+
+ class OldNum:
+ def __float__(self):
+ return 6.25
+
+ def __int__(self):
+ return 8
+
+ class OldNotNum:
+ pass
+
+ class OldSilly:
+ def __float__(self):
+ return None
+
+ def __int__(self):
+ return None
+
+ for tc in 'bBhHiIlL':
+ a = array(tc, [0])
+ raises(TypeError, a.__setitem__, 0, 1.0)
+ a[0] = 1
+ a[0] = Num()
+ assert a[0] == 7
+ raises(TypeError, a.__setitem__, NotNum())
+ a[0] = OldNum()
+ assert a[0] == 8
+ raises(TypeError, a.__setitem__, OldNotNum())
+ raises(TypeError, a.__setitem__, Silly())
+ raises(TypeError, a.__setitem__, OldSilly())
+
+ for tc in 'fd':
+ a = array(tc, [0])
+ a[0] = 1.0
+ a[0] = 1
+ a[0] = Num()
+ assert a[0] == 5.25
+ raises(TypeError, a.__setitem__, NotNum())
+ a[0] = OldNum()
+ assert a[0] == 6.25
+ raises(TypeError, a.__setitem__, OldNotNum())
+ raises(TypeError, a.__setitem__, Silly())
+ raises(TypeError, a.__setitem__, OldSilly())
+
+ a = array('c', 'hi')
+ a[0] = 'b'
+ assert a[0] == 'b'
+
+ a = array('u', u'hi')
+ a[0] = u'b'
+ assert a[0] == u'b'
+
class TestCPythonsOwnArray(BaseArrayTests):
diff --git a/pypy/module/cppyy/capi/__init__.py b/pypy/module/cppyy/capi/__init__.py
--- a/pypy/module/cppyy/capi/__init__.py
+++ b/pypy/module/cppyy/capi/__init__.py
@@ -9,8 +9,8 @@
# the selection of the desired backend (default is Reflex).
# choose C-API access method:
-from pypy.module.cppyy.capi.loadable_capi import *
-#from pypy.module.cppyy.capi.builtin_capi import *
+#from pypy.module.cppyy.capi.loadable_capi import *
+from pypy.module.cppyy.capi.builtin_capi import *
from pypy.module.cppyy.capi.capi_types import C_OBJECT,\
C_NULL_TYPE, C_NULL_OBJECT
diff --git a/pypy/module/cppyy/capi/builtin_capi.py b/pypy/module/cppyy/capi/builtin_capi.py
--- a/pypy/module/cppyy/capi/builtin_capi.py
+++ b/pypy/module/cppyy/capi/builtin_capi.py
@@ -1,8 +1,8 @@
from rpython.rtyper.lltypesystem import rffi, lltype
from rpython.rlib import jit
-import reflex_capi as backend
-#import cint_capi as backend
+#import reflex_capi as backend
+import cint_capi as backend
from pypy.module.cppyy.capi.capi_types import C_SCOPE, C_TYPE, C_OBJECT,\
C_METHOD, C_INDEX, C_INDEX_ARRAY, WLAVC_INDEX,\
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
@@ -241,7 +241,6 @@
it is necessary to serialize calls to this function."""
if not space.config.translation.thread:
raise NoThreads
- rthread.gc_thread_prepare()
# PyThreadState_Get will allocate a new execution context,
# we need to protect gc and other globals with the GIL.
rffi.aroundstate.after()
diff --git a/pypy/module/imp/importing.py b/pypy/module/imp/importing.py
--- a/pypy/module/imp/importing.py
+++ b/pypy/module/imp/importing.py
@@ -841,8 +841,7 @@
#
# default_magic - 6 -- used by CPython without the -U option
# default_magic - 5 -- used by CPython with the -U option
-# default_magic -- used by PyPy without the CALL_METHOD opcode
-# default_magic + 2 -- used by PyPy with the CALL_METHOD opcode
+# default_magic -- used by PyPy [because of CALL_METHOD]
#
from pypy.interpreter.pycode import default_magic
MARSHAL_VERSION_FOR_PYC = 2
@@ -855,10 +854,7 @@
magic = __import__('imp').get_magic()
return struct.unpack('<i', magic)[0]
- result = default_magic
- if space.config.objspace.opcodes.CALL_METHOD:
- result += 2
- return result
+ return default_magic
def parse_source_module(space, pathname, source):
diff --git a/pypy/module/imp/test/test_import.py b/pypy/module/imp/test/test_import.py
--- a/pypy/module/imp/test/test_import.py
+++ b/pypy/module/imp/test/test_import.py
@@ -992,6 +992,7 @@
assert ret == 42
def test_pyc_magic_changes(self):
+ py.test.skip("For now, PyPy generates only one kind of .pyc files")
# test that the pyc files produced by a space are not reimportable
# from another, if they differ in what opcodes they support
allspaces = [self.space]
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
@@ -396,6 +396,8 @@
class W_UnicodeBox(W_CharacterBox):
def descr__new__unicode_box(space, w_subtype, w_arg):
+ raise OperationError(space.w_NotImplementedError, space.wrap("Unicode is not supported yet"))
+
from pypy.module.micronumpy.interp_dtype import new_unicode_dtype
arg = space.unicode_w(unicode_from_object(space, w_arg))
diff --git a/pypy/module/micronumpy/interp_dtype.py b/pypy/module/micronumpy/interp_dtype.py
--- a/pypy/module/micronumpy/interp_dtype.py
+++ b/pypy/module/micronumpy/interp_dtype.py
@@ -685,7 +685,7 @@
name='string',
char='S',
w_box_type = space.gettypefor(interp_boxes.W_StringBox),
- alternate_constructors=[space.w_str],
+ alternate_constructors=[space.w_str, space.gettypefor(interp_boxes.W_CharacterBox)],
aliases=["str"],
)
self.w_unicodedtype = W_Dtype(
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
@@ -88,13 +88,27 @@
w_res = W_NDimArray.from_shape(space, res_shape, self.get_dtype(), w_instance=self)
return loop.getitem_filter(w_res, self, arr)
- def setitem_filter(self, space, idx, val):
+ def setitem_filter(self, space, idx, value):
+ from pypy.module.micronumpy.interp_boxes import Box
+ val = value
if len(idx.get_shape()) > 1 and idx.get_shape() != self.get_shape():
raise OperationError(space.w_ValueError,
space.wrap("boolean index array should have 1 dimension"))
if idx.get_size() > self.get_size():
raise OperationError(space.w_ValueError,
space.wrap("index out of range for array"))
+ idx_iter = idx.create_iter(self.get_shape())
+ size = loop.count_all_true_iter(idx_iter, self.get_shape(), idx.get_dtype())
+ if len(val.get_shape()) > 0 and val.get_shape()[0] > 1 and size > val.get_shape()[0]:
+ raise OperationError(space.w_ValueError, space.wrap("NumPy boolean array indexing assignment "
+ "cannot assign %d input values to "
+ "the %d output values where the mask is true" % (val.get_shape()[0],size)))
+ if val.get_shape() == [1]:
+ box = val.descr_getitem(space, space.wrap(0))
+ assert isinstance(box, Box)
+ val = W_NDimArray(scalar.Scalar(val.get_dtype(), box))
+ elif val.get_shape() == [0]:
+ val.implementation.dtype = self.implementation.dtype
loop.setitem_filter(self, idx, val)
def _prepare_array_index(self, space, w_index):
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
@@ -132,7 +132,7 @@
reduce_driver = jit.JitDriver(name='numpy_reduce',
greens = ['shapelen', 'func', 'done_func',
- 'calc_dtype', 'identity'],
+ 'calc_dtype'],
reds = 'auto')
def compute_reduce(obj, calc_dtype, func, done_func, identity):
@@ -146,7 +146,7 @@
while not obj_iter.done():
reduce_driver.jit_merge_point(shapelen=shapelen, func=func,
done_func=done_func,
- calc_dtype=calc_dtype, identity=identity,
+ calc_dtype=calc_dtype,
)
rval = obj_iter.getitem().convert_to(calc_dtype)
if done_func is not None and done_func(calc_dtype, rval):
@@ -318,23 +318,27 @@
lefti.next()
return result
-count_all_true_driver = jit.JitDriver(name = 'numpy_count',
- greens = ['shapelen', 'dtype'],
- reds = 'auto')
def count_all_true(arr):
- s = 0
if arr.is_scalar():
return arr.get_dtype().itemtype.bool(arr.get_scalar_value())
iter = arr.create_iter()
- shapelen = len(arr.get_shape())
- dtype = arr.get_dtype()
+ return count_all_true_iter(iter, arr.get_shape(), arr.get_dtype())
+
+count_all_true_iter_driver = jit.JitDriver(name = 'numpy_count',
+ greens = ['shapelen', 'dtype'],
+ reds = 'auto')
+def count_all_true_iter(iter, shape, dtype):
+ s = 0
+ shapelen = len(shape)
+ dtype = dtype
while not iter.done():
- count_all_true_driver.jit_merge_point(shapelen=shapelen, dtype=dtype)
+ count_all_true_iter_driver.jit_merge_point(shapelen=shapelen, dtype=dtype)
s += iter.getitem_bool()
iter.next()
return s
+
getitem_filter_driver = jit.JitDriver(name = 'numpy_getitem_bool',
greens = ['shapelen', 'arr_dtype',
'index_dtype'],
@@ -370,7 +374,7 @@
def setitem_filter(arr, index, value):
arr_iter = arr.create_iter()
- index_iter = index.create_iter()
+ index_iter = index.create_iter(arr.get_shape())
value_iter = value.create_iter()
shapelen = len(arr.get_shape())
index_dtype = index.get_dtype()
diff --git a/pypy/module/micronumpy/test/test_complex.py b/pypy/module/micronumpy/test/test_complex.py
--- a/pypy/module/micronumpy/test/test_complex.py
+++ b/pypy/module/micronumpy/test/test_complex.py
@@ -685,3 +685,8 @@
msg=error_message)
sys.stderr.write('.')
sys.stderr.write('\n')
+
+ def test_complexbox_to_pycomplex(self):
+ from numpypy import complex128
+ x = complex128(3.4j)
+ assert complex(x) == 3.4j
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
@@ -778,6 +778,11 @@
from numpypy import unicode_
assert isinstance(unicode_(3), unicode)
+ def test_character_dtype(self):
+ from numpypy import array, character
+ x = array([["A", "B"], ["C", "D"]], character)
+ assert (x == [["A", "B"], ["C", "D"]]).all()
+
class AppTestRecordDtypes(BaseNumpyAppTest):
spaceconfig = dict(usemodules=["micronumpy", "struct", "binascii"])
def test_create(self):
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
@@ -1922,6 +1922,29 @@
a = numpy.arange(10.).reshape((5, 2))[::2]
assert (loads(dumps(a)) == a).all()
+ def test_string_filling(self):
+ import numpypy as numpy
+ a = numpy.empty((10,10), dtype='c1')
+ a.fill(12)
+ assert (a == '1').all()
+
+ def test_boolean_indexing(self):
+ import numpypy as np
+ a = np.zeros((1, 3))
+ b = np.array([True])
+
+ assert (a[b] == a).all()
+
+ a[b] = 1.
+
+ assert (a == [[1., 1., 1.]]).all()
+
+ @py.test.mark.xfail
+ def test_boolean_array(self):
+ import numpypy as np
+ a = np.ndarray([1], dtype=bool)
+ assert a[0] == True
+
class AppTestMultiDim(BaseNumpyAppTest):
def test_init(self):
import numpypy
@@ -2329,6 +2352,21 @@
a[a & 1 == 0] = 15
assert (a == [[15, 1], [15, 5], [15, 9]]).all()
+ def test_array_indexing_bool_specialcases(self):
+ from numpypy import arange, array
+ a = arange(6)
+ try:
+ a[a < 3] = [1, 2]
+ assert False, "Should not work"
+ except ValueError:
+ pass
+ a = arange(6)
+ a[a > 3] = array([15])
+ assert (a == [0, 1, 2, 3, 15, 15]).all()
+ a = arange(6).reshape(3, 2)
+ a[a & 1 == 1] = [] # here, Numpy sticks garbage into the array
+ assert a.shape == (3, 2)
+
def test_copy_kwarg(self):
from numpypy import array
x = array([1, 2, 3])
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
@@ -257,6 +257,7 @@
def test_rint(self):
from numpypy import array, complex, rint, isnan
+ import sys
nnan, nan, inf, ninf = float('-nan'), float('nan'), float('inf'), float('-inf')
@@ -271,6 +272,8 @@
assert rint(complex(inf, 1.5)) == complex(inf, 2.)
assert rint(complex(0.5, inf)) == complex(0., inf)
+ assert rint(sys.maxint) > 0.0
+
def test_sign(self):
from numpypy import array, sign, dtype
diff --git a/pypy/module/micronumpy/test/test_zjit.py b/pypy/module/micronumpy/test/test_zjit.py
--- a/pypy/module/micronumpy/test/test_zjit.py
+++ b/pypy/module/micronumpy/test/test_zjit.py
@@ -56,7 +56,7 @@
elif isinstance(w_res, interp_boxes.W_BoolBox):
return float(w_res.value)
raise TypeError(w_res)
-
+
if self.graph is None:
interp, graph = self.meta_interp(f, [0],
listops=True,
@@ -139,11 +139,17 @@
'int_add': 3,
})
+ def define_reduce():
+ return """
+ a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ sum(a)
+ """
+
def test_reduce_compile_only_once(self):
self.compile_graph()
reset_stats()
pyjitpl._warmrunnerdesc.memory_manager.alive_loops.clear()
- i = self.code_mapping['sum']
+ i = self.code_mapping['reduce']
# run it twice
retval = self.interp.eval_graph(self.graph, [i])
retval = self.interp.eval_graph(self.graph, [i])
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
@@ -308,13 +308,6 @@
return min(v1, v2)
@simple_unary_op
- def rint(self, v):
- if isfinite(v):
- return rfloat.round_double(v, 0, half_even=True)
- else:
- return v
-
- @simple_unary_op
def ones_like(self, v):
return 1
@@ -322,6 +315,10 @@
def zeros_like(self, v):
return 0
+ @raw_unary_op
+ def rint(self, v):
+ float64 = Float64()
+ return float64.rint(float64.box(v))
class NonNativePrimitive(Primitive):
_mixin_ = True
@@ -1036,6 +1033,25 @@
else:
return v1 + v2
+ @simple_unary_op
+ def rint(self, v):
+ x = float(v)
+ if isfinite(x):
+ import math
+ y = math.floor(x)
+ r = x - y
+
+ if r > 0.5:
+ y += 1.0
+
+ if r == 0.5:
+ r = y - 2.0 * math.floor(0.5 * y)
+ if r == 1.0:
+ y += 1.0
+ return y
+ else:
+ return x
+
class NonNativeFloat(NonNativePrimitive, Float):
_mixin_ = True
@@ -1748,12 +1764,16 @@
arr.storage[i] = arg[i]
return interp_boxes.W_StringBox(arr, 0, arr.dtype)
- @jit.unroll_safe
def store(self, arr, i, offset, box):
assert isinstance(box, interp_boxes.W_StringBox)
# XXX simplify to range(box.dtype.get_size()) ?
+ return self._store(arr.storage, i, offset, box)
+
+ @jit.unroll_safe
+ def _store(self, storage, i, offset, box):
+ assert isinstance(box, interp_boxes.W_StringBox)
for k in range(min(self.size, box.arr.size-offset)):
- arr.storage[k + i] = box.arr.storage[k + offset]
+ storage[k + i] = box.arr.storage[k + offset]
def read(self, arr, i, offset, dtype=None):
if dtype is None:
@@ -1843,6 +1863,11 @@
arr.storage[j] = '\x00'
return interp_boxes.W_StringBox(arr, 0, arr.dtype)
+ def fill(self, storage, width, box, start, stop, offset):
+ from pypy.module.micronumpy.arrayimpl.concrete import ConcreteArrayNotOwning
+ for i in xrange(start, stop, width):
+ self._store(storage, i, offset, box)
+
NonNativeStringType = StringType
class UnicodeType(BaseType, BaseStringType):
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
@@ -1,5 +1,3 @@
-
-import py, sys
from pypy.module.pypyjit.test_pypy_c.test_00_model import BaseTestPyPyC
@@ -51,27 +49,6 @@
...
""")
- def test_list(self):
- def main(n):
- i = 0
- while i < n:
- z = list(())
- z.append(1)
- i += z[-1] / len(z)
- return i
-
- log = self.run(main, [1000])
- assert log.result == main(1000)
- loop, = log.loops_by_filename(self.filepath)
- assert loop.match("""
- i7 = int_lt(i5, i6)
- guard_true(i7, descr=...)
More information about the pypy-commit
mailing list