[pypy-commit] pypy default: merge
cfbolz
pypy.commits at gmail.com
Fri Aug 4 11:26:16 EDT 2017
Author: Carl Friedrich Bolz <cfbolz at gmx.de>
Branch:
Changeset: r92077:8c68d973f65b
Date: 2017-08-04 17:25 +0200
http://bitbucket.org/pypy/pypy/changeset/8c68d973f65b/
Log: merge
diff --git a/Makefile b/Makefile
--- a/Makefile
+++ b/Makefile
@@ -10,7 +10,7 @@
RUNINTERP = $(PYPY_EXECUTABLE)
endif
-.PHONY: cffi_imports
+.PHONY: pypy-c cffi_imports
pypy-c:
@echo
@@ -32,7 +32,7 @@
@echo "===================================================================="
@echo
@sleep 5
- $(RUNINTERP) rpython/bin/rpython -Ojit pypy/goal/targetpypystandalone.py
+ cd pypy/goal && $(RUNINTERP) ../../rpython/bin/rpython -Ojit targetpypystandalone.py
# Note: the -jN option, or MAKEFLAGS=-jN, are not usable. They are
# replaced with an opaque --jobserver option by the time this Makefile
@@ -40,4 +40,4 @@
# http://lists.gnu.org/archive/html/help-make/2010-08/msg00106.html
cffi_imports: pypy-c
- PYTHONPATH=. ./pypy-c pypy/tool/build_cffi_imports.py || /bin/true
+ PYTHONPATH=. pypy/goal/pypy-c pypy/tool/build_cffi_imports.py || /bin/true
diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py
--- a/pypy/config/pypyoption.py
+++ b/pypy/config/pypyoption.py
@@ -224,11 +224,6 @@
"use specialised tuples",
default=False),
- BoolOption("withcelldict",
- "use dictionaries that are optimized for being used as module dicts",
- default=False,
- requires=[("objspace.honor__builtins__", False)]),
-
BoolOption("withliststrategies",
"enable optimized ways to store lists of primitives ",
default=True),
@@ -288,7 +283,7 @@
# extra optimizations with the JIT
if level == 'jit':
- config.objspace.std.suggest(withcelldict=True)
+ pass # none at the moment
def enable_allworkingmodules(config):
diff --git a/pypy/doc/config/objspace.std.withcelldict.txt b/pypy/doc/config/objspace.std.withcelldict.txt
deleted file mode 100644
--- a/pypy/doc/config/objspace.std.withcelldict.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-Enable cell-dicts. This optimization is not helpful without the JIT. In the
-presence of the JIT, it greatly helps looking up globals.
diff --git a/pypy/interpreter/argument.py b/pypy/interpreter/argument.py
--- a/pypy/interpreter/argument.py
+++ b/pypy/interpreter/argument.py
@@ -2,6 +2,7 @@
Arguments objects.
"""
from rpython.rlib.debug import make_sure_not_resized
+from rpython.rlib.objectmodel import not_rpython
from rpython.rlib import jit
from pypy.interpreter.error import OperationError, oefmt
@@ -46,8 +47,8 @@
# behaviour but produces better error messages
self.methodcall = methodcall
+ @not_rpython
def __repr__(self):
- """ NOT_RPYTHON """
name = self.__class__.__name__
if not self.keywords:
return '%s(%s)' % (name, self.arguments_w,)
diff --git a/pypy/interpreter/error.py b/pypy/interpreter/error.py
--- a/pypy/interpreter/error.py
+++ b/pypy/interpreter/error.py
@@ -7,6 +7,7 @@
from rpython.rlib import jit
from rpython.rlib.objectmodel import we_are_translated, specialize
+from rpython.rlib.objectmodel import not_rpython
from rpython.rlib import rstack, rstackovf
from pypy.interpreter import debug
@@ -57,8 +58,9 @@
self.match(space, space.w_KeyboardInterrupt))
# note: an extra case is added in OpErrFmtNoArgs
+ @not_rpython
def __str__(self):
- "NOT_RPYTHON: Convenience for tracebacks."
+ "Convenience for tracebacks."
s = self._w_value
space = getattr(self.w_type, 'space', None)
if space is not None:
@@ -107,15 +109,16 @@
if RECORD_INTERPLEVEL_TRACEBACK:
self.debug_excs.append(sys.exc_info())
+ @not_rpython
def print_application_traceback(self, space, file=None):
- "NOT_RPYTHON: Dump a standard application-level traceback."
+ "Dump a standard application-level traceback."
if file is None:
file = sys.stderr
self.print_app_tb_only(file)
print >> file, self.errorstr(space)
+ @not_rpython
def print_app_tb_only(self, file):
- "NOT_RPYTHON"
tb = self._application_traceback
if tb:
import linecache
@@ -142,8 +145,9 @@
print >> file, l
tb = tb.next
+ @not_rpython
def print_detailed_traceback(self, space=None, file=None):
- """NOT_RPYTHON: Dump a nice detailed interpreter- and
+ """Dump a nice detailed interpreter- and
application-level traceback, useful to debug the interpreter."""
if file is None:
file = sys.stderr
diff --git a/pypy/interpreter/executioncontext.py b/pypy/interpreter/executioncontext.py
--- a/pypy/interpreter/executioncontext.py
+++ b/pypy/interpreter/executioncontext.py
@@ -1,7 +1,7 @@
import sys
from pypy.interpreter.error import OperationError, get_cleared_operation_error
from rpython.rlib.unroll import unrolling_iterable
-from rpython.rlib.objectmodel import specialize
+from rpython.rlib.objectmodel import specialize, not_rpython
from rpython.rlib import jit, rgc, objectmodel
TICK_COUNTER_STEP = 100
@@ -423,8 +423,9 @@
# to run at the next possible bytecode
self.reset_ticker(-1)
+ @not_rpython
def register_periodic_action(self, action, use_bytecode_counter):
- """NOT_RPYTHON:
+ """
Register the PeriodicAsyncAction action to be called whenever the
tick counter becomes smaller than 0. If 'use_bytecode_counter' is
True, make sure that we decrease the tick counter at every bytecode.
diff --git a/pypy/interpreter/gateway.py b/pypy/interpreter/gateway.py
--- a/pypy/interpreter/gateway.py
+++ b/pypy/interpreter/gateway.py
@@ -23,7 +23,7 @@
DescrMismatch)
from pypy.interpreter.error import OperationError, oefmt
from pypy.interpreter.function import ClassMethod, FunctionWithFixedCode
-from rpython.rlib.objectmodel import we_are_translated
+from rpython.rlib.objectmodel import we_are_translated, not_rpython
from rpython.rlib.rarithmetic import r_longlong, r_int, r_ulonglong, r_uint
from rpython.tool.sourcetools import func_with_new_name, compile2
@@ -64,8 +64,8 @@
def _freeze_(self):
return True
+ @not_rpython
def unwrap(self, space, w_value):
- """NOT_RPYTHON"""
raise NotImplementedError
@@ -380,8 +380,8 @@
class BuiltinActivation(object):
_immutable_ = True
+ @not_rpython
def __init__(self, behavior):
- """NOT_RPYTHON"""
self.behavior = behavior
def _run(self, space, scope_w):
@@ -621,9 +621,9 @@
# When a BuiltinCode is stored in a Function object,
# you get the functionality of CPython's built-in function type.
+ @not_rpython
def __init__(self, func, unwrap_spec=None, self_type=None,
descrmismatch=None, doc=None):
- "NOT_RPYTHON"
# 'implfunc' is the interpreter-level function.
# Note that this uses a lot of (construction-time) introspection.
Code.__init__(self, func.__name__)
@@ -969,10 +969,10 @@
instancecache = {}
+ @not_rpython
def __new__(cls, f, app_name=None, unwrap_spec=None, descrmismatch=None,
as_classmethod=False, doc=None):
- "NOT_RPYTHON"
# f must be a function whose name does NOT start with 'app_'
self_type = None
if hasattr(f, 'im_func'):
@@ -1013,8 +1013,8 @@
self._staticdefs = zip(argnames[-len(defaults):], defaults)
return self
+ @not_rpython
def _getdefaults(self, space):
- "NOT_RPYTHON"
defs_w = []
for name, defaultval in self._staticdefs:
if name.startswith('w_'):
@@ -1070,8 +1070,8 @@
class GatewayCache(SpaceCache):
+ @not_rpython
def build(cache, gateway):
- "NOT_RPYTHON"
space = cache.space
defs = gateway._getdefaults(space) # needs to be implemented by subclass
code = gateway._code
@@ -1141,8 +1141,8 @@
w_globals = self.getwdict(space)
return space.getitem(w_globals, space.newtext(name))
+ @not_rpython
def interphook(self, name):
- "NOT_RPYTHON"
def appcaller(space, *args_w):
if not isinstance(space, ObjSpace):
raise TypeError("first argument must be a space instance.")
@@ -1179,15 +1179,16 @@
"""NOT_RPYTHON
The cache mapping each applevel instance to its lazily built w_dict"""
+ @not_rpython
def build(self, app):
- "NOT_RPYTHON. Called indirectly by Applevel.getwdict()."
+ "Called indirectly by Applevel.getwdict()."
return build_applevel_dict(app, self.space)
# __________ pure applevel version __________
+ at not_rpython
def build_applevel_dict(self, space):
- "NOT_RPYTHON"
w_glob = space.newdict(module=True)
space.setitem(w_glob, space.newtext('__name__'), space.newtext(self.modname))
space.exec_(self.source, w_glob, w_glob,
@@ -1198,8 +1199,9 @@
# ____________________________________________________________
+ at not_rpython
def appdef(source, applevel=ApplevelClass, filename=None):
- """ NOT_RPYTHON: build an app-level helper function, like for example:
+ """ build an app-level helper function, like for example:
myfunc = appdef('''myfunc(x, y):
return x+y
''')
@@ -1245,6 +1247,6 @@
# app2interp_temp is used for testing mainly
+ at not_rpython
def app2interp_temp(func, applevel_temp=applevel_temp, filename=None):
- """ NOT_RPYTHON """
return appdef(func, applevel_temp, filename=filename)
diff --git a/pypy/interpreter/miscutils.py b/pypy/interpreter/miscutils.py
--- a/pypy/interpreter/miscutils.py
+++ b/pypy/interpreter/miscutils.py
@@ -3,6 +3,7 @@
"""
from rpython.rlib.listsort import make_timsort_class
+from rpython.rlib.objectmodel import not_rpython
class ThreadLocals:
@@ -41,9 +42,8 @@
# but in some corner cases it is not... unsure why
self._value = None
-
+ at not_rpython
def make_weak_value_dictionary(space, keytype, valuetype):
- "NOT_RPYTHON"
if space.config.translation.rweakref:
from rpython.rlib.rweakref import RWeakValueDictionary
return RWeakValueDictionary(keytype, valuetype)
diff --git a/pypy/interpreter/mixedmodule.py b/pypy/interpreter/mixedmodule.py
--- a/pypy/interpreter/mixedmodule.py
+++ b/pypy/interpreter/mixedmodule.py
@@ -3,6 +3,9 @@
from pypy.interpreter import gateway
from pypy.interpreter.error import OperationError
from pypy.interpreter.baseobjspace import W_Root
+
+from rpython.rlib.objectmodel import not_rpython
+
import sys
class MixedModule(Module):
@@ -15,16 +18,17 @@
lazy = False
submodule_name = None
+ @not_rpython
def __init__(self, space, w_name):
- """ NOT_RPYTHON """
Module.__init__(self, space, w_name)
self.lazy = True
self.__class__.buildloaders()
self.loaders = self.loaders.copy() # copy from the class to the inst
self.submodules_w = []
+ @not_rpython
def install(self):
- """NOT_RPYTHON: install this module, and it's submodules into
+ """install this module, and it's submodules into
space.builtin_modules"""
Module.install(self)
if hasattr(self, "submodules"):
@@ -61,8 +65,8 @@
self.w_initialdict = self.space.call_method(self.w_dict, 'items')
@classmethod
+ @not_rpython
def get_applevel_name(cls):
- """ NOT_RPYTHON """
if cls.applevel_name is not None:
return cls.applevel_name
else:
@@ -130,8 +134,8 @@
self._frozen = True
@classmethod
+ @not_rpython
def buildloaders(cls):
- """ NOT_RPYTHON """
if not hasattr(cls, 'loaders'):
# build a constant dictionary out of
# applevel/interplevel definitions
@@ -161,8 +165,8 @@
return space.newtext_or_none(cls.__doc__)
+ at not_rpython
def getinterpevalloader(pkgroot, spec):
- """ NOT_RPYTHON """
def ifileloader(space):
d = {'space':space}
# EVIL HACK (but it works, and this is not RPython :-)
@@ -202,8 +206,8 @@
return ifileloader
applevelcache = {}
+ at not_rpython
def getappfileloader(pkgroot, appname, spec):
- """ NOT_RPYTHON """
# hum, it's a bit more involved, because we usually
# want the import at applevel
modname, attrname = spec.split('.')
diff --git a/pypy/interpreter/module.py b/pypy/interpreter/module.py
--- a/pypy/interpreter/module.py
+++ b/pypy/interpreter/module.py
@@ -4,7 +4,7 @@
from pypy.interpreter.baseobjspace import W_Root
from pypy.interpreter.error import OperationError
-from rpython.rlib.objectmodel import we_are_translated
+from rpython.rlib.objectmodel import we_are_translated, not_rpython
class Module(W_Root):
@@ -40,13 +40,15 @@
except OperationError:
pass
+ @not_rpython
def install(self):
- """NOT_RPYTHON: installs this module into space.builtin_modules"""
+ """installs this module into space.builtin_modules"""
modulename = self.space.text0_w(self.w_name)
self.space.builtin_modules[modulename] = self
+ @not_rpython
def setup_after_space_initialization(self):
- """NOT_RPYTHON: to allow built-in modules to do some more setup
+ """to allow built-in modules to do some more setup
after the space is fully initialized."""
def init(self, space):
diff --git a/pypy/interpreter/pyframe.py b/pypy/interpreter/pyframe.py
--- a/pypy/interpreter/pyframe.py
+++ b/pypy/interpreter/pyframe.py
@@ -7,6 +7,7 @@
from rpython.rlib.debug import ll_assert_not_none
from rpython.rlib.jit import hint
from rpython.rlib.objectmodel import instantiate, specialize, we_are_translated
+from rpython.rlib.objectmodel import not_rpython
from rpython.rlib.rarithmetic import intmask, r_uint
from rpython.tool.pairtype import extendabletype
@@ -144,8 +145,9 @@
return None
return d.w_locals
+ @not_rpython
def __repr__(self):
- # NOT_RPYTHON: useful in tracebacks
+ # useful in tracebacks
return "<%s.%s executing %s at line %s" % (
self.__class__.__module__, self.__class__.__name__,
self.pycode, self.get_last_lineno())
diff --git a/pypy/interpreter/pyopcode.py b/pypy/interpreter/pyopcode.py
--- a/pypy/interpreter/pyopcode.py
+++ b/pypy/interpreter/pyopcode.py
@@ -7,7 +7,7 @@
from rpython.rlib import jit, rstackovf
from rpython.rlib.debug import check_nonneg
from rpython.rlib.objectmodel import (we_are_translated, always_inline,
- dont_inline)
+ dont_inline, not_rpython)
from rpython.rlib.rarithmetic import r_uint, intmask
from rpython.tool.sourcetools import func_with_new_name
@@ -20,8 +20,8 @@
from pypy.interpreter.pycode import PyCode, BytecodeCorruption
from pypy.tool.stdlib_opcode import bytecode_spec
+ at not_rpython
def unaryoperation(operationname):
- """NOT_RPYTHON"""
def opimpl(self, *ignored):
operation = getattr(self.space, operationname)
w_1 = self.popvalue()
@@ -31,8 +31,8 @@
return func_with_new_name(opimpl, "opcode_impl_for_%s" % operationname)
+ at not_rpython
def binaryoperation(operationname):
- """NOT_RPYTHON"""
def opimpl(self, *ignored):
operation = getattr(self.space, operationname)
w_2 = self.popvalue()
diff --git a/pypy/interpreter/typedef.py b/pypy/interpreter/typedef.py
--- a/pypy/interpreter/typedef.py
+++ b/pypy/interpreter/typedef.py
@@ -8,14 +8,15 @@
from rpython.rlib.jit import promote
from rpython.rlib.objectmodel import compute_identity_hash, specialize
-from rpython.rlib.objectmodel import instantiate
+from rpython.rlib.objectmodel import instantiate, not_rpython
from rpython.tool.sourcetools import compile2, func_with_new_name
class TypeDef(object):
+ @not_rpython
def __init__(self, __name, __base=None, __total_ordering__=None,
__buffer=None, **rawdict):
- "NOT_RPYTHON: initialization-time only"
+ "initialization-time only"
self.name = __name
if __base is None:
bases = []
@@ -113,8 +114,9 @@
# register_finalizer() or not.
@specialize.memo()
+ at not_rpython
def get_unique_interplevel_subclass(space, cls):
- "NOT_RPYTHON: initialization-time only"
+ "initialization-time only"
assert cls.typedef.acceptable_as_base_class
try:
return _unique_subclass_cache[cls]
@@ -349,15 +351,17 @@
return self
+ at not_rpython
def interp_attrproperty(name, cls, doc=None, wrapfn=None):
- "NOT_RPYTHON: initialization-time only"
+ "initialization-time only"
assert wrapfn is not None
def fget(space, obj):
return getattr(space, wrapfn)(getattr(obj, name))
return GetSetProperty(fget, cls=cls, doc=doc)
+ at not_rpython
def interp_attrproperty_w(name, cls, doc=None):
- "NOT_RPYTHON: initialization-time only"
+ "initialization-time only"
def fget(space, obj):
w_value = getattr(obj, name)
if w_value is None:
diff --git a/pypy/module/__builtin__/test/test_classobj.py b/pypy/module/__builtin__/test/test_classobj.py
--- a/pypy/module/__builtin__/test/test_classobj.py
+++ b/pypy/module/__builtin__/test/test_classobj.py
@@ -1090,18 +1090,18 @@
def setup_class(cls):
if cls.runappdirect:
py.test.skip("can only be run on py.py")
- def is_strdict(space, w_class):
- from pypy.objspace.std.dictmultiobject import BytesDictStrategy
+ def is_moduledict(space, w_class):
+ from pypy.objspace.std.celldict import ModuleDictStrategy
w_d = w_class.getdict(space)
- return space.wrap(isinstance(w_d.get_strategy(), BytesDictStrategy))
+ return space.wrap(isinstance(w_d.get_strategy(), ModuleDictStrategy))
- cls.w_is_strdict = cls.space.wrap(gateway.interp2app(is_strdict))
+ cls.w_is_moduledict = cls.space.wrap(gateway.interp2app(is_moduledict))
- def test_strdict(self):
+ def test_moduledict(self):
class A:
a = 1
b = 2
- assert self.is_strdict(A)
+ assert self.is_moduledict(A)
def test_attr_slots(self):
class C:
diff --git a/pypy/module/_codecs/__init__.py b/pypy/module/_codecs/__init__.py
--- a/pypy/module/_codecs/__init__.py
+++ b/pypy/module/_codecs/__init__.py
@@ -1,5 +1,6 @@
from pypy.interpreter.mixedmodule import MixedModule
from rpython.rlib import runicode
+from rpython.rlib.objectmodel import not_rpython
from pypy.module._codecs import interp_codecs
class Module(MixedModule):
@@ -86,9 +87,8 @@
'unicode_internal_encode' : 'interp_codecs.unicode_internal_encode',
}
+ @not_rpython
def __init__(self, space, *args):
- "NOT_RPYTHON"
-
# mbcs codec is Windows specific, and based on rffi.
if (hasattr(runicode, 'str_decode_mbcs')):
self.interpleveldefs['mbcs_encode'] = 'interp_codecs.mbcs_encode'
diff --git a/pypy/module/_codecs/interp_codecs.py b/pypy/module/_codecs/interp_codecs.py
--- a/pypy/module/_codecs/interp_codecs.py
+++ b/pypy/module/_codecs/interp_codecs.py
@@ -1,5 +1,5 @@
from rpython.rlib import jit
-from rpython.rlib.objectmodel import we_are_translated
+from rpython.rlib.objectmodel import we_are_translated, not_rpython
from rpython.rlib.rstring import UnicodeBuilder
from rpython.rlib.runicode import code_to_unichr, MAXUNICODE
@@ -268,8 +268,8 @@
raise oefmt(space.w_TypeError,
"don't know how to handle %T in error callback", w_exc)
+ at not_rpython
def register_builtin_error_handlers(space):
- "NOT_RPYTHON"
state = space.fromcache(CodecState)
for error in ("strict", "ignore", "replace", "xmlcharrefreplace",
"backslashreplace"):
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
@@ -118,6 +118,29 @@
return space.w_True
return space.w_False
+index_count_jd = jit.JitDriver(
+ greens = ['count', 'arrclass', 'tp_item'],
+ reds = 'auto', name = 'array.index_or_count')
+
+def index_count_array(arr, w_val, count=False):
+ space = arr.space
+ tp_item = space.type(w_val)
+ arrclass = arr.__class__
+ cnt = 0
+ for i in range(arr.len):
+ index_count_jd.jit_merge_point(
+ tp_item=tp_item, count=count,
+ arrclass=arrclass)
+ w_item = arr.w_getitem(space, i)
+ if space.eq_w(w_item, w_val):
+ if count:
+ cnt += 1
+ else:
+ return i
+ if count:
+ return cnt
+ return -1
+
UNICODE_ARRAY = lltype.Ptr(lltype.Array(lltype.UniChar,
hints={'nolength': True}))
@@ -257,17 +280,12 @@
"""
self.extend(w_x)
- def descr_count(self, space, w_val):
+ def descr_count(self, space, w_x):
""" count(x)
Return number of occurrences of x in the array.
"""
- cnt = 0
- for i in range(self.len):
- # XXX jitdriver
- w_item = self.w_getitem(space, i)
- if space.eq_w(w_item, w_val):
- cnt += 1
+ cnt = index_count_array(self, w_x, count=True)
return space.newint(cnt)
def descr_index(self, space, w_x):
@@ -275,10 +293,9 @@
Return index of first occurrence of x in the array.
"""
- for i in range(self.len):
- w_item = self.w_getitem(space, i)
- if space.eq_w(w_item, w_x):
- return space.newint(i)
+ res = index_count_array(self, w_x, count=False)
+ if res >= 0:
+ return space.newint(res)
raise oefmt(space.w_ValueError, "array.index(x): x not in list")
def descr_reverse(self, space):
@@ -752,7 +769,9 @@
class TypeCode(object):
def __init__(self, itemtype, unwrap, canoverflow=False, signed=False,
- method='__int__'):
+ method='__int__', errorname=None):
+ if errorname is None:
+ errorname = unwrap[:-2]
self.itemtype = itemtype
self.bytes = rffi.sizeof(itemtype)
self.arraytype = lltype.Array(itemtype, hints={'nolength': True})
@@ -762,6 +781,7 @@
self.canoverflow = canoverflow
self.w_class = None
self.method = method
+ self.errorname = errorname
def _freeze_(self):
# hint for the annotator: track individual constant instances
@@ -785,8 +805,8 @@
'i': TypeCode(rffi.INT, 'int_w', True, True),
'I': _UINTTypeCode,
'l': TypeCode(rffi.LONG, 'int_w', True, True),
- 'L': TypeCode(rffi.ULONG, 'bigint_w'), # Overflow handled by
- # rbigint.touint() which
+ 'L': TypeCode(rffi.ULONG, 'bigint_w', # Overflow handled by
+ errorname="integer"), # rbigint.touint() which
# corresponds to the
# C-type unsigned long
'f': TypeCode(lltype.SingleFloat, 'float_w', method='__float__'),
@@ -864,7 +884,7 @@
item = unwrap(space.call_method(w_item, mytype.method))
except OperationError:
raise oefmt(space.w_TypeError,
- "array item must be " + mytype.unwrap[:-2])
+ "array item must be " + mytype.errorname)
else:
raise
if mytype.unwrap == 'bigint_w':
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
@@ -162,6 +162,11 @@
raises(OverflowError, a.append, -1)
raises(OverflowError, a.append, 2 ** (8 * b))
+ def test_errormessage(self):
+ a = self.array("L", [1, 2, 3])
+ excinfo = raises(TypeError, "a[0] = 'abc'")
+ assert str(excinfo.value) == "array item must be integer"
+
def test_fromstring(self):
import sys
diff --git a/pypy/module/posix/interp_posix.py b/pypy/module/posix/interp_posix.py
--- a/pypy/module/posix/interp_posix.py
+++ b/pypy/module/posix/interp_posix.py
@@ -3,7 +3,7 @@
from rpython.rlib import rposix, rposix_stat
from rpython.rlib import objectmodel, rurandom
-from rpython.rlib.objectmodel import specialize
+from rpython.rlib.objectmodel import specialize, not_rpython
from rpython.rlib.rarithmetic import r_longlong, intmask, r_uint
from rpython.rlib.unroll import unrolling_iterable
@@ -731,8 +731,8 @@
else:
assert False, "Unknown fork hook"
+ at not_rpython
def add_fork_hook(where, hook):
- "NOT_RPYTHON"
get_fork_hooks(where).append(hook)
add_fork_hook('child', ExecutionContext._mark_thread_disappeared)
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
@@ -56,7 +56,7 @@
def allocate_and_init_instance(space, w_type=None, module=False,
instance=False, strdict=False,
kwargs=False):
- if space.config.objspace.std.withcelldict and module:
+ if module:
from pypy.objspace.std.celldict import ModuleDictStrategy
assert w_type is None
# every module needs its own strategy, because the strategy stores
diff --git a/pypy/objspace/std/objspace.py b/pypy/objspace/std/objspace.py
--- a/pypy/objspace/std/objspace.py
+++ b/pypy/objspace/std/objspace.py
@@ -181,8 +181,8 @@
return self._wrap_not_rpython(x)
+ @not_rpython
def _wrap_not_rpython(self, x):
- "NOT_RPYTHON"
# _____ this code is here to support testing only _____
# wrap() of a container works on CPython, but the code is
diff --git a/pypy/objspace/std/test/test_celldict.py b/pypy/objspace/std/test/test_celldict.py
--- a/pypy/objspace/std/test/test_celldict.py
+++ b/pypy/objspace/std/test/test_celldict.py
@@ -58,7 +58,6 @@
assert v2 is v3
class AppTestModuleDict(object):
- spaceconfig = {"objspace.std.withcelldict": True}
def setup_class(cls):
cls.w_runappdirect = cls.space.wrap(cls.runappdirect)
@@ -116,7 +115,6 @@
class AppTestCellDict(object):
- spaceconfig = {"objspace.std.withcelldict": True}
def setup_class(cls):
if cls.runappdirect:
diff --git a/pypy/objspace/std/test/test_dictmultiobject.py b/pypy/objspace/std/test/test_dictmultiobject.py
--- a/pypy/objspace/std/test/test_dictmultiobject.py
+++ b/pypy/objspace/std/test/test_dictmultiobject.py
@@ -1261,7 +1261,6 @@
class Config:
class objspace:
class std:
- withcelldict = False
methodcachesizeexp = 11
withmethodcachecounter = False
@@ -1467,6 +1466,7 @@
def test_module_uses_strdict():
+ from pypy.objspace.std.celldict import ModuleDictStrategy
fakespace = FakeSpace()
d = fakespace.newdict(module=True)
- assert type(d.get_strategy()) is BytesDictStrategy
+ assert type(d.get_strategy()) is ModuleDictStrategy
diff --git a/pypy/objspace/std/test/test_mapdict.py b/pypy/objspace/std/test/test_mapdict.py
--- a/pypy/objspace/std/test/test_mapdict.py
+++ b/pypy/objspace/std/test/test_mapdict.py
@@ -4,7 +4,6 @@
class Config:
class objspace:
class std:
- withcelldict = False
methodcachesizeexp = 11
withmethodcachecounter = False
diff --git a/pypy/objspace/std/typeobject.py b/pypy/objspace/std/typeobject.py
--- a/pypy/objspace/std/typeobject.py
+++ b/pypy/objspace/std/typeobject.py
@@ -11,7 +11,7 @@
from rpython.rlib.jit import (promote, elidable_promote, we_are_jitted,
elidable, dont_look_inside, unroll_safe)
from rpython.rlib.objectmodel import current_object_addr_as_int, compute_hash
-from rpython.rlib.objectmodel import we_are_translated
+from rpython.rlib.objectmodel import we_are_translated, not_rpython
from rpython.rlib.rarithmetic import intmask, r_uint
class MutableCell(W_Root):
@@ -212,8 +212,8 @@
else:
self.terminator = NoDictTerminator(space, self)
+ @not_rpython
def __repr__(self):
- "NOT_RPYTHON"
return '<W_TypeObject %r at 0x%x>' % (self.name, id(self))
def mutated(self, key):
@@ -492,8 +492,9 @@
self, w_subtype, w_subtype)
return w_subtype
+ @not_rpython
def _cleanup_(self):
- "NOT_RPYTHON. Forces the lazy attributes to be computed."
+ "Forces the lazy attributes to be computed."
if 'lazyloaders' in self.__dict__:
for attr in self.lazyloaders.keys():
self.getdictvalue(self.space, attr)
@@ -1317,8 +1318,9 @@
class TypeCache(SpaceCache):
+ @not_rpython
def build(self, typedef):
- "NOT_RPYTHON: initialization-time only."
+ "initialization-time only."
from pypy.objspace.std.objectobject import W_ObjectObject
from pypy.interpreter.typedef import GetSetProperty
from rpython.rlib.objectmodel import instantiate
More information about the pypy-commit
mailing list