[pypy-commit] pypy speedup-unpackiterable: merge default
fijal
noreply at buildbot.pypy.org
Fri Jul 20 17:33:26 CEST 2012
Author: Maciej Fijalkowski <fijall at gmail.com>
Branch: speedup-unpackiterable
Changeset: r56292:a95f24ea5f0c
Date: 2012-07-20 17:33 +0200
http://bitbucket.org/pypy/pypy/changeset/a95f24ea5f0c/
Log: merge default
diff --git a/pypy/annotation/binaryop.py b/pypy/annotation/binaryop.py
--- a/pypy/annotation/binaryop.py
+++ b/pypy/annotation/binaryop.py
@@ -7,7 +7,7 @@
from pypy.tool.pairtype import pair, pairtype
from pypy.annotation.model import SomeObject, SomeInteger, SomeBool, s_Bool
from pypy.annotation.model import SomeString, SomeChar, SomeList, SomeDict
-from pypy.annotation.model import SomeUnicodeCodePoint
+from pypy.annotation.model import SomeUnicodeCodePoint, SomeStringOrUnicode
from pypy.annotation.model import SomeTuple, SomeImpossibleValue, s_ImpossibleValue
from pypy.annotation.model import SomeInstance, SomeBuiltin, SomeIterator
from pypy.annotation.model import SomePBC, SomeFloat, s_None
@@ -470,30 +470,37 @@
"string formatting mixing strings and unicode not supported")
-class __extend__(pairtype(SomeString, SomeTuple)):
- def mod((str, s_tuple)):
+class __extend__(pairtype(SomeString, SomeTuple),
+ pairtype(SomeUnicodeString, SomeTuple)):
+ def mod((s_string, s_tuple)):
+ is_string = isinstance(s_string, SomeString)
+ is_unicode = isinstance(s_string, SomeUnicodeString)
+ assert is_string or is_unicode
for s_item in s_tuple.items:
- if isinstance(s_item, (SomeUnicodeCodePoint, SomeUnicodeString)):
+ if (is_unicode and isinstance(s_item, (SomeChar, SomeString)) or
+ is_string and isinstance(s_item, (SomeUnicodeCodePoint,
+ SomeUnicodeString))):
raise NotImplementedError(
"string formatting mixing strings and unicode not supported")
- getbookkeeper().count('strformat', str, s_tuple)
- no_nul = str.no_nul
+ getbookkeeper().count('strformat', s_string, s_tuple)
+ no_nul = s_string.no_nul
for s_item in s_tuple.items:
if isinstance(s_item, SomeFloat):
pass # or s_item is a subclass, like SomeInteger
- elif isinstance(s_item, SomeString) and s_item.no_nul:
+ elif isinstance(s_item, SomeStringOrUnicode) and s_item.no_nul:
pass
else:
no_nul = False
break
- return SomeString(no_nul=no_nul)
+ return s_string.__class__(no_nul=no_nul)
-class __extend__(pairtype(SomeString, SomeObject)):
+class __extend__(pairtype(SomeString, SomeObject),
+ pairtype(SomeUnicodeString, SomeObject)):
- def mod((str, args)):
- getbookkeeper().count('strformat', str, args)
- return SomeString()
+ def mod((s_string, args)):
+ getbookkeeper().count('strformat', s_string, args)
+ return s_string.__class__()
class __extend__(pairtype(SomeFloat, SomeFloat)):
diff --git a/pypy/annotation/test/test_annrpython.py b/pypy/annotation/test/test_annrpython.py
--- a/pypy/annotation/test/test_annrpython.py
+++ b/pypy/annotation/test/test_annrpython.py
@@ -3389,6 +3389,22 @@
s = a.build_types(f, [str])
assert isinstance(s, annmodel.SomeString)
+ def test_unicodeformatting(self):
+ def f(x):
+ return u'%s' % x
+
+ a = self.RPythonAnnotator()
+ s = a.build_types(f, [unicode])
+ assert isinstance(s, annmodel.SomeUnicodeString)
+
+ def test_unicodeformatting_tuple(self):
+ def f(x):
+ return u'%s' % (x,)
+
+ a = self.RPythonAnnotator()
+ s = a.build_types(f, [unicode])
+ assert isinstance(s, annmodel.SomeUnicodeString)
+
def test_negative_slice(self):
def f(s, e):
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
@@ -255,7 +255,12 @@
code if the translator can prove that they are non-negative. When
slicing a string it is necessary to prove that the slice start and
stop indexes are non-negative. There is no implicit str-to-unicode cast
- anywhere.
+ anywhere. Simple string formatting using the ``%`` operator works, as long
+ as the format string is known at translation time; the only supported
+ formatting specifiers are ``%s``, ``%d``, ``%x``, ``%o``, ``%f``, plus
+ ``%r`` but only for user-defined instances. Modifiers such as conversion
+ flags, precision, length etc. are not supported. Moreover, it is forbidden
+ to mix unicode and strings when formatting.
**tuples**
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
@@ -14,5 +14,12 @@
.. branch: nupypy-axis-arg-check
Check that axis arg is valid in _numpypy
+.. branch: iterator-in-rpython
+.. branch: numpypy_count_nonzero
+.. branch: even-more-jit-hooks
+Implement better JIT hooks
+
.. "uninteresting" branches that we should just ignore for the whatsnew:
.. branch: slightly-shorter-c
+.. branch: better-enforceargs
+.. branch: rpython-unicode-formatting
diff --git a/pypy/jit/backend/llgraph/llimpl.py b/pypy/jit/backend/llgraph/llimpl.py
--- a/pypy/jit/backend/llgraph/llimpl.py
+++ b/pypy/jit/backend/llgraph/llimpl.py
@@ -1522,6 +1522,7 @@
def do_new_array(arraynum, count):
TYPE = symbolic.Size2Type[arraynum]
+ assert count >= 0 # explode if it's not
x = lltype.malloc(TYPE, count, zero=True)
return cast_to_ptr(x)
diff --git a/pypy/jit/backend/x86/assembler.py b/pypy/jit/backend/x86/assembler.py
--- a/pypy/jit/backend/x86/assembler.py
+++ b/pypy/jit/backend/x86/assembler.py
@@ -1375,6 +1375,11 @@
genop_cast_ptr_to_int = genop_same_as
genop_cast_int_to_ptr = genop_same_as
+ def genop_int_force_ge_zero(self, op, arglocs, resloc):
+ self.mc.TEST(arglocs[0], arglocs[0])
+ self.mov(imm0, resloc)
+ self.mc.CMOVNS(arglocs[0], resloc)
+
def genop_int_mod(self, op, arglocs, resloc):
if IS_X86_32:
self.mc.CDQ()
diff --git a/pypy/jit/backend/x86/regalloc.py b/pypy/jit/backend/x86/regalloc.py
--- a/pypy/jit/backend/x86/regalloc.py
+++ b/pypy/jit/backend/x86/regalloc.py
@@ -1188,6 +1188,12 @@
consider_cast_ptr_to_int = consider_same_as
consider_cast_int_to_ptr = consider_same_as
+ def consider_int_force_ge_zero(self, op):
+ argloc = self.loc(op.getarg(0))
+ resloc = self.force_allocate_reg(op.result, [op.getarg(0)])
+ self.possibly_free_var(op.getarg(0))
+ self.Perform(op, [argloc], resloc)
+
def consider_strlen(self, op):
args = op.getarglist()
base_loc = self.rm.make_sure_var_in_reg(op.getarg(0), args)
diff --git a/pypy/jit/backend/x86/regloc.py b/pypy/jit/backend/x86/regloc.py
--- a/pypy/jit/backend/x86/regloc.py
+++ b/pypy/jit/backend/x86/regloc.py
@@ -548,6 +548,7 @@
# Avoid XCHG because it always implies atomic semantics, which is
# slower and does not pair well for dispatch.
#XCHG = _binaryop('XCHG')
+ CMOVNS = _binaryop('CMOVNS')
PUSH = _unaryop('PUSH')
POP = _unaryop('POP')
diff --git a/pypy/jit/backend/x86/rx86.py b/pypy/jit/backend/x86/rx86.py
--- a/pypy/jit/backend/x86/rx86.py
+++ b/pypy/jit/backend/x86/rx86.py
@@ -530,6 +530,8 @@
NOT_r = insn(rex_w, '\xF7', register(1), '\xD0')
NOT_b = insn(rex_w, '\xF7', orbyte(2<<3), stack_bp(1))
+ CMOVNS_rr = insn(rex_w, '\x0F\x49', register(2, 8), register(1), '\xC0')
+
# ------------------------------ Misc stuff ------------------------------
NOP = insn('\x90')
diff --git a/pypy/jit/backend/x86/test/test_rx86_32_auto_encoding.py b/pypy/jit/backend/x86/test/test_rx86_32_auto_encoding.py
--- a/pypy/jit/backend/x86/test/test_rx86_32_auto_encoding.py
+++ b/pypy/jit/backend/x86/test/test_rx86_32_auto_encoding.py
@@ -317,7 +317,9 @@
# CALL_j is actually relative, so tricky to test
(instrname == 'CALL' and argmodes == 'j') or
# SET_ir must be tested manually
- (instrname == 'SET' and argmodes == 'ir')
+ (instrname == 'SET' and argmodes == 'ir') or
+ # asm gets CMOVNS args the wrong way
+ (instrname.startswith('CMOV'))
)
diff --git a/pypy/jit/backend/x86/test/test_ztranslation.py b/pypy/jit/backend/x86/test/test_ztranslation.py
--- a/pypy/jit/backend/x86/test/test_ztranslation.py
+++ b/pypy/jit/backend/x86/test/test_ztranslation.py
@@ -181,6 +181,7 @@
i += 1
def main():
+ jit_hooks.stats_set_debug(None, True)
f()
ll_times = jit_hooks.stats_get_loop_run_times(None)
return len(ll_times)
diff --git a/pypy/jit/codewriter/jtransform.py b/pypy/jit/codewriter/jtransform.py
--- a/pypy/jit/codewriter/jtransform.py
+++ b/pypy/jit/codewriter/jtransform.py
@@ -1430,7 +1430,10 @@
def do_fixed_newlist(self, op, args, arraydescr):
v_length = self._get_initial_newlist_length(op, args)
- return SpaceOperation('new_array', [arraydescr, v_length], op.result)
+ v = Variable('new_length')
+ v.concretetype = lltype.Signed
+ return [SpaceOperation('int_force_ge_zero', [v_length], v),
+ SpaceOperation('new_array', [arraydescr, v], op.result)]
def do_fixed_list_len(self, op, args, arraydescr):
if args[0] in self.vable_array_vars: # virtualizable array
diff --git a/pypy/jit/codewriter/test/test_codewriter.py b/pypy/jit/codewriter/test/test_codewriter.py
--- a/pypy/jit/codewriter/test/test_codewriter.py
+++ b/pypy/jit/codewriter/test/test_codewriter.py
@@ -221,3 +221,17 @@
assert 'setarrayitem_raw_i' in s
assert 'getarrayitem_raw_i' in s
assert 'residual_call_ir_v $<* fn _ll_1_raw_free__arrayPtr>' in s
+
+def test_newlist_negativ():
+ def f(n):
+ l = [0] * n
+ return len(l)
+
+ rtyper = support.annotate(f, [-1])
+ jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
+ cw = CodeWriter(FakeCPU(rtyper), [jitdriver_sd])
+ cw.find_all_graphs(FakePolicy())
+ cw.make_jitcodes(verbose=True)
+ s = jitdriver_sd.mainjitcode.dump()
+ assert 'int_force_ge_zero' in s
+ assert 'new_array' in s
diff --git a/pypy/jit/metainterp/blackhole.py b/pypy/jit/metainterp/blackhole.py
--- a/pypy/jit/metainterp/blackhole.py
+++ b/pypy/jit/metainterp/blackhole.py
@@ -477,6 +477,11 @@
@arguments("i", "i", "i", returns="i")
def bhimpl_int_between(a, b, c):
return a <= b < c
+ @arguments("i", returns="i")
+ def bhimpl_int_force_ge_zero(i):
+ if i < 0:
+ return 0
+ return i
@arguments("i", "i", returns="i")
def bhimpl_uint_lt(a, b):
diff --git a/pypy/jit/metainterp/compile.py b/pypy/jit/metainterp/compile.py
--- a/pypy/jit/metainterp/compile.py
+++ b/pypy/jit/metainterp/compile.py
@@ -225,6 +225,8 @@
assert isinstance(target_token, TargetToken)
assert loop_jitcell_token.target_tokens
loop_jitcell_token.target_tokens.append(target_token)
+ if target_token.short_preamble:
+ metainterp_sd.logger_ops.log_short_preamble([], target_token.short_preamble)
loop = partial_trace
loop.operations = loop.operations[:-1] + part.operations
diff --git a/pypy/jit/metainterp/history.py b/pypy/jit/metainterp/history.py
--- a/pypy/jit/metainterp/history.py
+++ b/pypy/jit/metainterp/history.py
@@ -706,6 +706,7 @@
self.virtual_state = None
self.exported_state = None
+ self.short_preamble = None
def repr_of_descr(self):
return 'TargetToken(%d)' % compute_unique_id(self)
diff --git a/pypy/jit/metainterp/optimizeopt/rewrite.py b/pypy/jit/metainterp/optimizeopt/rewrite.py
--- a/pypy/jit/metainterp/optimizeopt/rewrite.py
+++ b/pypy/jit/metainterp/optimizeopt/rewrite.py
@@ -241,6 +241,16 @@
# guard_nonnull_class on this value, which is rather silly.
# replace the original guard with a guard_value
old_guard_op = value.last_guard
+ if old_guard_op.getopnum() != rop.GUARD_NONNULL:
+ # This is only safe if the class of the guard_value matches the
+ # class of the guard_*_class, otherwise the intermediate ops might
+ # be executed with wrong classes.
+ previous_classbox = value.get_constant_class(self.optimizer.cpu)
+ expected_classbox = self.optimizer.cpu.ts.cls_of_box(op.getarg(1))
+ assert previous_classbox is not None
+ assert expected_classbox is not None
+ if not previous_classbox.same_constant(expected_classbox):
+ raise InvalidLoop('A GUARD_VALUE was proven to always fail')
op = old_guard_op.copy_and_change(rop.GUARD_VALUE,
args = [old_guard_op.getarg(0), op.getarg(1)])
self.optimizer.replaces_guard[op] = old_guard_op
@@ -251,6 +261,8 @@
assert isinstance(descr, compile.ResumeGuardDescr)
descr.guard_opnum = rop.GUARD_VALUE
descr.make_a_counter_per_value(op)
+ # to be safe
+ value.last_guard = None
constbox = op.getarg(1)
assert isinstance(constbox, Const)
self.optimize_guard(op, constbox)
diff --git a/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py b/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
--- a/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
+++ b/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
@@ -7862,6 +7862,17 @@
"""
self.optimize_loop(ops, expected)
+ def test_only_strengthen_guard_if_class_matches(self):
+ ops = """
+ [p1]
+ guard_class(p1, ConstClass(node_vtable2)) []
+ guard_value(p1, ConstPtr(myptr)) []
+ jump(p1)
+ """
+ self.raises(InvalidLoop, self.optimize_loop,
+ ops, ops)
+
+
class TestLLtype(OptimizeOptTest, LLtypeMixin):
pass
diff --git a/pypy/jit/metainterp/optimizeopt/unroll.py b/pypy/jit/metainterp/optimizeopt/unroll.py
--- a/pypy/jit/metainterp/optimizeopt/unroll.py
+++ b/pypy/jit/metainterp/optimizeopt/unroll.py
@@ -120,9 +120,9 @@
limit = self.optimizer.metainterp_sd.warmrunnerdesc.memory_manager.retrace_limit
if cell_token.retraced_count < limit:
cell_token.retraced_count += 1
- #debug_print('Retracing (%d/%d)' % (cell_token.retraced_count, limit))
+ debug_print('Retracing (%d/%d)' % (cell_token.retraced_count, limit))
else:
- #debug_print("Retrace count reached, jumping to preamble")
+ debug_print("Retrace count reached, jumping to preamble")
assert cell_token.target_tokens[0].virtual_state is None
jumpop.setdescr(cell_token.target_tokens[0])
self.optimizer.send_extra_operation(jumpop)
diff --git a/pypy/jit/metainterp/pyjitpl.py b/pypy/jit/metainterp/pyjitpl.py
--- a/pypy/jit/metainterp/pyjitpl.py
+++ b/pypy/jit/metainterp/pyjitpl.py
@@ -222,7 +222,7 @@
'float_neg', 'float_abs',
'cast_ptr_to_int', 'cast_int_to_ptr',
'convert_float_bytes_to_longlong',
- 'convert_longlong_bytes_to_float',
+ 'convert_longlong_bytes_to_float', 'int_force_ge_zero',
]:
exec py.code.Source('''
@arguments("box")
diff --git a/pypy/jit/metainterp/resoperation.py b/pypy/jit/metainterp/resoperation.py
--- a/pypy/jit/metainterp/resoperation.py
+++ b/pypy/jit/metainterp/resoperation.py
@@ -443,6 +443,7 @@
'INT_IS_TRUE/1b',
'INT_NEG/1',
'INT_INVERT/1',
+ 'INT_FORCE_GE_ZERO/1',
#
'SAME_AS/1', # gets a Const or a Box, turns it into another Box
'CAST_PTR_TO_INT/1',
diff --git a/pypy/jit/metainterp/resume.py b/pypy/jit/metainterp/resume.py
--- a/pypy/jit/metainterp/resume.py
+++ b/pypy/jit/metainterp/resume.py
@@ -10,6 +10,7 @@
from pypy.rpython import annlowlevel
from pypy.rlib import rarithmetic, rstack
from pypy.rlib.objectmodel import we_are_translated, specialize
+from pypy.rlib.objectmodel import compute_unique_id
from pypy.rlib.debug import have_debug_prints, ll_assert
from pypy.rlib.debug import debug_start, debug_stop, debug_print
from pypy.jit.metainterp.optimize import InvalidLoop
@@ -493,7 +494,7 @@
return self.setfields(decoder, struct)
def debug_prints(self):
- debug_print("\tvirtualinfo", self.known_class.repr_rpython())
+ debug_print("\tvirtualinfo", self.known_class.repr_rpython(), " at ", compute_unique_id(self))
AbstractVirtualStructInfo.debug_prints(self)
@@ -509,7 +510,7 @@
return self.setfields(decoder, struct)
def debug_prints(self):
- debug_print("\tvstructinfo", self.typedescr.repr_rpython())
+ debug_print("\tvstructinfo", self.typedescr.repr_rpython(), " at ", compute_unique_id(self))
AbstractVirtualStructInfo.debug_prints(self)
class VArrayInfo(AbstractVirtualInfo):
@@ -539,7 +540,7 @@
return array
def debug_prints(self):
- debug_print("\tvarrayinfo", self.arraydescr)
+ debug_print("\tvarrayinfo", self.arraydescr, " at ", compute_unique_id(self))
for i in self.fieldnums:
debug_print("\t\t", str(untag(i)))
@@ -550,7 +551,7 @@
self.fielddescrs = fielddescrs
def debug_prints(self):
- debug_print("\tvarraystructinfo", self.arraydescr)
+ debug_print("\tvarraystructinfo", self.arraydescr, " at ", compute_unique_id(self))
for i in self.fieldnums:
debug_print("\t\t", str(untag(i)))
@@ -581,7 +582,7 @@
return string
def debug_prints(self):
- debug_print("\tvstrplaininfo length", len(self.fieldnums))
+ debug_print("\tvstrplaininfo length", len(self.fieldnums), " at ", compute_unique_id(self))
class VStrConcatInfo(AbstractVirtualInfo):
@@ -599,7 +600,7 @@
return string
def debug_prints(self):
- debug_print("\tvstrconcatinfo")
+ debug_print("\tvstrconcatinfo at ", compute_unique_id(self))
for i in self.fieldnums:
debug_print("\t\t", str(untag(i)))
@@ -615,7 +616,7 @@
return string
def debug_prints(self):
- debug_print("\tvstrsliceinfo")
+ debug_print("\tvstrsliceinfo at ", compute_unique_id(self))
for i in self.fieldnums:
debug_print("\t\t", str(untag(i)))
@@ -636,7 +637,7 @@
return string
def debug_prints(self):
- debug_print("\tvuniplaininfo length", len(self.fieldnums))
+ debug_print("\tvuniplaininfo length", len(self.fieldnums), " at ", compute_unique_id(self))
class VUniConcatInfo(AbstractVirtualInfo):
@@ -654,7 +655,7 @@
return string
def debug_prints(self):
- debug_print("\tvuniconcatinfo")
+ debug_print("\tvuniconcatinfo at ", compute_unique_id(self))
for i in self.fieldnums:
debug_print("\t\t", str(untag(i)))
@@ -671,7 +672,7 @@
return string
def debug_prints(self):
- debug_print("\tvunisliceinfo")
+ debug_print("\tvunisliceinfo at ", compute_unique_id(self))
for i in self.fieldnums:
debug_print("\t\t", str(untag(i)))
@@ -1280,7 +1281,6 @@
def dump_storage(storage, liveboxes):
"For profiling only."
- from pypy.rlib.objectmodel import compute_unique_id
debug_start("jit-resume")
if have_debug_prints():
debug_print('Log storage', compute_unique_id(storage))
diff --git a/pypy/jit/metainterp/test/test_dict.py b/pypy/jit/metainterp/test/test_dict.py
--- a/pypy/jit/metainterp/test/test_dict.py
+++ b/pypy/jit/metainterp/test/test_dict.py
@@ -161,6 +161,22 @@
'guard_no_exception': 8, 'new': 2,
'guard_false': 2, 'int_is_true': 2})
+ def test_unrolling_of_dict_iter(self):
+ driver = JitDriver(greens = [], reds = ['n'])
+
+ def f(n):
+ while n > 0:
+ driver.jit_merge_point(n=n)
+ d = {1: 1}
+ for elem in d:
+ n -= elem
+ return n
+
+ res = self.meta_interp(f, [10], listops=True)
+ assert res == 0
+ self.check_simple_loop({'int_sub': 1, 'int_gt': 1, 'guard_true': 1,
+ 'jump': 1})
+
class TestOOtype(DictTests, OOJitMixin):
pass
diff --git a/pypy/jit/metainterp/test/test_list.py b/pypy/jit/metainterp/test/test_list.py
--- a/pypy/jit/metainterp/test/test_list.py
+++ b/pypy/jit/metainterp/test/test_list.py
@@ -251,6 +251,16 @@
self.meta_interp(f, [10], listops=True)
self.check_resops(new_array=0, call=0)
+ def test_list_mul(self):
+ def f(i):
+ l = [0] * i
+ return len(l)
+
+ r = self.interp_operations(f, [3])
+ assert r == 3
+ r = self.interp_operations(f, [-1])
+ assert r == 0
+
class TestOOtype(ListTests, OOJitMixin):
pass
diff --git a/pypy/module/__pypy__/__init__.py b/pypy/module/__pypy__/__init__.py
--- a/pypy/module/__pypy__/__init__.py
+++ b/pypy/module/__pypy__/__init__.py
@@ -43,6 +43,8 @@
'do_what_I_mean' : 'interp_magic.do_what_I_mean',
'list_strategy' : 'interp_magic.list_strategy',
'validate_fd' : 'interp_magic.validate_fd',
+ 'newdict' : 'interp_dict.newdict',
+ 'dictstrategy' : 'interp_dict.dictstrategy',
}
if sys.platform == 'win32':
interpleveldefs['get_console_cp'] = 'interp_magic.get_console_cp'
diff --git a/pypy/module/__pypy__/interp_dict.py b/pypy/module/__pypy__/interp_dict.py
new file mode 100644
--- /dev/null
+++ b/pypy/module/__pypy__/interp_dict.py
@@ -0,0 +1,24 @@
+
+from pypy.interpreter.gateway import unwrap_spec
+from pypy.interpreter.error import operationerrfmt, OperationError
+from pypy.objspace.std.dictmultiobject import W_DictMultiObject
+
+ at unwrap_spec(type=str)
+def newdict(space, type):
+ if type == 'module':
+ return space.newdict(module=True)
+ elif type == 'instance':
+ return space.newdict(instance=True)
+ elif type == 'kwargs':
+ return space.newdict(kwargs=True)
+ elif type == 'strdict':
+ return space.newdict(strdict=True)
+ else:
+ raise operationerrfmt(space.w_TypeError, "unknown type of dict %s",
+ type)
+
+def dictstrategy(space, w_obj):
+ if not isinstance(w_obj, W_DictMultiObject):
+ raise OperationError(space.w_TypeError,
+ space.wrap("expecting dict object"))
+ return space.wrap('%r' % (w_obj.strategy,))
diff --git a/pypy/module/pypyjit/test_pypy_c/test_call.py b/pypy/module/pypyjit/test_pypy_c/test_call.py
--- a/pypy/module/pypyjit/test_pypy_c/test_call.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_call.py
@@ -1,5 +1,6 @@
import py
from pypy.module.pypyjit.test_pypy_c.test_00_model import BaseTestPyPyC
+from pypy.module.pypyjit.test_pypy_c.model import OpMatcher
class TestCall(BaseTestPyPyC):
@@ -376,6 +377,7 @@
setfield_gc(p26, ConstPtr(ptr22), descr=<FieldP pypy.objspace.std.listobject.W_ListObject.inst_strategy .*>)
setarrayitem_gc(p24, 0, p26, descr=<ArrayP .>)
setfield_gc(p22, p24, descr=<FieldP .*Arguments.inst_arguments_w .*>)
+ setfield_gc(p22, 1, descr=<FieldU .*Arguments.inst__jit_few_keywords .*>)
p32 = call_may_force(11376960, p18, p22, descr=<Callr . rr EF=6>)
...
""")
@@ -506,7 +508,6 @@
return res""", [1000])
assert log.result == 500
loop, = log.loops_by_id('call')
- print loop.ops_by_id('call')
assert loop.match("""
i65 = int_lt(i58, i29)
guard_true(i65, descr=...)
@@ -522,3 +523,97 @@
jump(..., descr=...)
""")
+ def test_kwargs_virtual3(self):
+ log = self.run("""
+ def f(a, b, c):
+ pass
+
+ def main(stop):
+ i = 0
+ while i < stop:
+ d = {'a': 2, 'b': 3, 'c': 4}
+ f(**d) # ID: call
+ i += 1
+ return 13
+ """, [1000])
+ assert log.result == 13
+ loop, = log.loops_by_id('call')
+ allops = loop.allops()
+ calls = [op for op in allops if op.name.startswith('call')]
+ assert len(calls) == 0
+ assert len([op for op in allops if op.name.startswith('new')]) == 0
+
+ def test_kwargs_non_virtual(self):
+ log = self.run("""
+ def f(a, b, c):
+ pass
+
+ def main(stop):
+ d = {'a': 2, 'b': 3, 'c': 4}
+ i = 0
+ while i < stop:
+ f(**d) # ID: call
+ i += 1
+ return 13
+ """, [1000])
+ assert log.result == 13
+ loop, = log.loops_by_id('call')
+ allops = loop.allops()
+ calls = [op for op in allops if op.name.startswith('call')]
+ assert OpMatcher(calls).match('''
+ p93 = call(ConstClass(view_as_kwargs), p35, p12, descr=<.*>)
+ i103 = call(ConstClass(_match_keywords), ConstPtr(ptr52), 0, 0, p94, p98, 0, descr=<.*>)
+ ''')
+ assert len([op for op in allops if op.name.startswith('new')]) == 1
+ # 1 alloc
+
+ def test_complex_case(self):
+ log = self.run("""
+ def f(x, y, a, b, c=3, d=4):
+ pass
+
+ def main(stop):
+ i = 0
+ while i < stop:
+ a = [1, 2]
+ d = {'a': 2, 'b': 3, 'd':4}
+ f(*a, **d) # ID: call
+ i += 1
+ return 13
+ """, [1000])
+ loop, = log.loops_by_id('call')
+ assert loop.match_by_id('call', '''
+ guard_not_invalidated(descr=<.*>)
+ i1 = force_token()
+ ''')
+
+ def test_complex_case_global(self):
+ log = self.run("""
+ def f(x, y, a, b, c=3, d=4):
+ pass
+
+ a = [1, 2]
+ d = {'a': 2, 'b': 3, 'd':4}
+
+ def main(stop):
+ i = 0
+ while i < stop:
+ f(*a, **d) # ID: call
+ i += 1
+ return 13
+ """, [1000])
+
+ def test_complex_case_loopconst(self):
+ log = self.run("""
+ def f(x, y, a, b, c=3, d=4):
+ pass
+
+ def main(stop):
+ i = 0
+ a = [1, 2]
+ d = {'a': 2, 'b': 3, 'd':4}
+ while i < stop:
+ f(*a, **d) # ID: call
+ i += 1
+ return 13
+ """, [1000])
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
@@ -13,6 +13,7 @@
from pypy.tool.sourcetools import func_with_new_name
from pypy.rlib import rerased
+from pypy.rlib import jit
def _is_str(space, w_key):
return space.is_w(space.type(w_key), space.w_str)
@@ -30,6 +31,18 @@
space.is_w(w_lookup_type, space.w_float)
)
+
+DICT_CUTOFF = 5
+
+ at specialize.call_location()
+def w_dict_unrolling_heuristic(w_dct):
+ """ In which cases iterating over dict items can be unrolled.
+ Note that w_dct is an instance of W_DictMultiObject, not necesarilly
+ an actual dict
+ """
+ return jit.isvirtual(w_dct) or (jit.isconstant(w_dct) and
+ w_dct.length() <= DICT_CUTOFF)
+
class W_DictMultiObject(W_Object):
from pypy.objspace.std.dicttype import dict_typedef as typedef
@@ -92,6 +105,9 @@
for w_k, w_v in list_pairs_w:
w_self.setitem(w_k, w_v)
+ def view_as_kwargs(self):
+ return self.strategy.view_as_kwargs(self)
+
def _add_indirections():
dict_methods = "setitem setitem_str getitem \
getitem_str delitem length \
@@ -588,8 +604,23 @@
def w_keys(self, w_dict):
return self.space.newlist_str(self.listview_str(w_dict))
+<<<<<<< local
def wrapkey(space, key):
return space.wrap(key)
+=======
+ @jit.look_inside_iff(lambda self, w_dict:
+ w_dict_unrolling_heuristic(w_dict))
+ def view_as_kwargs(self, w_dict):
+ d = self.unerase(w_dict.dstorage)
+ l = len(d)
+ keys, values = [None] * l, [None] * l
+ i = 0
+ for key, val in d.iteritems():
+ keys[i] = key
+ values[i] = val
+ i += 1
+ return keys, values
+>>>>>>> other
def view_as_kwargs(self, w_dict):
d = self.unerase(w_dict.dstorage)
diff --git a/pypy/objspace/std/strutil.py b/pypy/objspace/std/strutil.py
--- a/pypy/objspace/std/strutil.py
+++ b/pypy/objspace/std/strutil.py
@@ -185,4 +185,4 @@
try:
return rstring_to_float(s)
except ValueError:
- raise ParseStringError("invalid literal for float()")
+ raise ParseStringError("invalid literal for float(): '%s'" % s)
diff --git a/pypy/objspace/std/test/test_floatobject.py b/pypy/objspace/std/test/test_floatobject.py
--- a/pypy/objspace/std/test/test_floatobject.py
+++ b/pypy/objspace/std/test/test_floatobject.py
@@ -441,6 +441,13 @@
b = A(5).real
assert type(b) is float
+ def test_invalid_literal_message(self):
+ try:
+ float('abcdef')
+ except ValueError, e:
+ assert 'abcdef' in e.message
+ else:
+ assert False, 'did not raise'
class AppTestFloatHex:
def w_identical(self, x, y):
diff --git a/pypy/objspace/std/test/test_methodcache.py b/pypy/objspace/std/test/test_methodcache.py
--- a/pypy/objspace/std/test/test_methodcache.py
+++ b/pypy/objspace/std/test/test_methodcache.py
@@ -1,8 +1,8 @@
from pypy.conftest import gettestobjspace
-from pypy.objspace.std.test.test_typeobject import AppTestTypeObject
+from pypy.objspace.std.test import test_typeobject
-class AppTestMethodCaching(AppTestTypeObject):
+class AppTestMethodCaching(test_typeobject.AppTestTypeObject):
def setup_class(cls):
cls.space = gettestobjspace(
**{"objspace.std.withmethodcachecounter": True})
diff --git a/pypy/rlib/objectmodel.py b/pypy/rlib/objectmodel.py
--- a/pypy/rlib/objectmodel.py
+++ b/pypy/rlib/objectmodel.py
@@ -3,9 +3,11 @@
RPython-compliant way.
"""
+import py
import sys
import types
import math
+import inspect
# specialize is a decorator factory for attaching _annspecialcase_
# attributes to functions: for example
@@ -106,15 +108,68 @@
specialize = _Specialize()
-def enforceargs(*args):
+def enforceargs(*types, **kwds):
""" Decorate a function with forcing of RPython-level types on arguments.
None means no enforcing.
- XXX shouldn't we also add asserts in function body?
+ When not translated, the type of the actual arguments are checked against
+ the enforced types every time the function is called. You can disable the
+ typechecking by passing ``typecheck=False`` to @enforceargs.
"""
+ typecheck = kwds.pop('typecheck', True)
+ if kwds:
+ raise TypeError, 'got an unexpected keyword argument: %s' % kwds.keys()
+ if not typecheck:
+ def decorator(f):
+ f._annenforceargs_ = types
+ return f
+ return decorator
+ #
+ from pypy.annotation.signature import annotationoftype
+ from pypy.annotation.model import SomeObject
def decorator(f):
- f._annenforceargs_ = args
- return f
+ def get_annotation(t):
+ if isinstance(t, SomeObject):
+ return t
+ return annotationoftype(t)
+ def typecheck(*args):
+ for i, (expected_type, arg) in enumerate(zip(types, args)):
+ if expected_type is None:
+ continue
+ s_expected = get_annotation(expected_type)
+ s_argtype = get_annotation(type(arg))
+ if not s_expected.contains(s_argtype):
+ msg = "%s argument number %d must be of type %s" % (
+ f.func_name, i+1, expected_type)
+ raise TypeError, msg
+ #
+ # we cannot simply wrap the function using *args, **kwds, because it's
+ # not RPython. Instead, we generate a function with exactly the same
+ # argument list
+ argspec = inspect.getargspec(f)
+ assert len(argspec.args) == len(types), (
+ 'not enough types provided: expected %d, got %d' %
+ (len(types), len(argspec.args)))
+ assert not argspec.varargs, '*args not supported by enforceargs'
+ assert not argspec.keywords, '**kwargs not supported by enforceargs'
+ #
+ arglist = ', '.join(argspec.args)
+ src = py.code.Source("""
+ def {name}({arglist}):
+ if not we_are_translated():
+ typecheck({arglist})
+ return {name}_original({arglist})
+ """.format(name=f.func_name, arglist=arglist))
+ #
+ mydict = {f.func_name + '_original': f,
+ 'typecheck': typecheck,
+ 'we_are_translated': we_are_translated}
+ exec src.compile() in mydict
+ result = mydict[f.func_name]
+ result.func_defaults = f.func_defaults
+ result.func_dict.update(f.func_dict)
+ result._annenforceargs_ = types
+ return result
return decorator
# ____________________________________________________________
diff --git a/pypy/rlib/rgc.py b/pypy/rlib/rgc.py
--- a/pypy/rlib/rgc.py
+++ b/pypy/rlib/rgc.py
@@ -138,8 +138,8 @@
return hop.genop(opname, vlist, resulttype = hop.r_result.lowleveltype)
@jit.oopspec('list.ll_arraycopy(source, dest, source_start, dest_start, length)')
+ at enforceargs(None, None, int, int, int)
@specialize.ll()
- at enforceargs(None, None, int, int, int)
def ll_arraycopy(source, dest, source_start, dest_start, length):
from pypy.rpython.lltypesystem.lloperation import llop
from pypy.rlib.objectmodel import keepalive_until_here
diff --git a/pypy/rlib/test/test_objectmodel.py b/pypy/rlib/test/test_objectmodel.py
--- a/pypy/rlib/test/test_objectmodel.py
+++ b/pypy/rlib/test/test_objectmodel.py
@@ -420,9 +420,45 @@
def test_enforceargs_decorator():
@enforceargs(int, str, None)
def f(a, b, c):
- pass
+ return a, b, c
+ f.foo = 'foo'
+ assert f._annenforceargs_ == (int, str, None)
+ assert f.func_name == 'f'
+ assert f.foo == 'foo'
+ assert f(1, 'hello', 42) == (1, 'hello', 42)
+ exc = py.test.raises(TypeError, "f(1, 2, 3)")
+ assert exc.value.message == "f argument number 2 must be of type <type 'str'>"
+ py.test.raises(TypeError, "f('hello', 'world', 3)")
+
+def test_enforceargs_defaults():
+ @enforceargs(int, int)
+ def f(a, b=40):
+ return a+b
+ assert f(2) == 42
+
+def test_enforceargs_int_float_promotion():
+ @enforceargs(float)
+ def f(x):
+ return x
+ # in RPython there is an implicit int->float promotion
+ assert f(42) == 42
+
+def test_enforceargs_no_typecheck():
+ @enforceargs(int, str, None, typecheck=False)
+ def f(a, b, c):
+ return a, b, c
assert f._annenforceargs_ == (int, str, None)
+ assert f(1, 2, 3) == (1, 2, 3) # no typecheck
+
+def test_enforceargs_translates():
+ from pypy.rpython.lltypesystem import lltype
+ @enforceargs(int, float)
+ def f(a, b):
+ return a, b
+ graph = getgraph(f, [int, int])
+ TYPES = [v.concretetype for v in graph.getargs()]
+ assert TYPES == [lltype.Signed, lltype.Float]
def getgraph(f, argtypes):
from pypy.translator.translator import TranslationContext, graphof
diff --git a/pypy/rpython/lltypesystem/rdict.py b/pypy/rpython/lltypesystem/rdict.py
--- a/pypy/rpython/lltypesystem/rdict.py
+++ b/pypy/rpython/lltypesystem/rdict.py
@@ -713,6 +713,10 @@
def _make_ll_dictnext(kind):
# make three versions of the following function: keys, values, items
+ @jit.look_inside_iff(lambda RETURNTYPE, iter: jit.isvirtual(iter)
+ and (iter.dict is None or
+ jit.isvirtual(iter.dict)))
+ @jit.oopspec("dictiter.next%s(iter)" % kind)
def ll_dictnext(RETURNTYPE, iter):
# note that RETURNTYPE is None for keys and values
dict = iter.dict
@@ -740,7 +744,6 @@
# clear the reference to the dict and prevent restarts
iter.dict = lltype.nullptr(lltype.typeOf(iter).TO.dict.TO)
raise StopIteration
- ll_dictnext.oopspec = 'dictiter.next%s(iter)' % kind
return ll_dictnext
ll_dictnext_group = {'keys' : _make_ll_dictnext('keys'),
diff --git a/pypy/rpython/lltypesystem/rstr.py b/pypy/rpython/lltypesystem/rstr.py
--- a/pypy/rpython/lltypesystem/rstr.py
+++ b/pypy/rpython/lltypesystem/rstr.py
@@ -1,9 +1,10 @@
from weakref import WeakValueDictionary
from pypy.tool.pairtype import pairtype
+from pypy.annotation import model as annmodel
from pypy.rpython.error import TyperError
from pypy.rlib.objectmodel import malloc_zero_filled, we_are_translated
from pypy.rlib.objectmodel import _hash_string, enforceargs
-from pypy.rlib.objectmodel import keepalive_until_here
+from pypy.rlib.objectmodel import keepalive_until_here, specialize
from pypy.rlib.debug import ll_assert
from pypy.rlib import jit
from pypy.rlib.rarithmetic import ovfcheck
@@ -169,6 +170,13 @@
return result
@jit.elidable
+ def ll_unicode(self, s):
+ if s:
+ return s
+ else:
+ return self.ll.ll_constant_unicode(u'None')
+
+ @jit.elidable
def ll_encode_latin1(self, s):
length = len(s.chars)
result = mallocstr(length)
@@ -955,20 +963,29 @@
def ll_build_finish(builder):
return LLHelpers.ll_join_strs(len(builder), builder)
+ @specialize.memo()
def ll_constant(s):
return string_repr.convert_const(s)
- ll_constant._annspecialcase_ = 'specialize:memo'
+
+ @specialize.memo()
+ def ll_constant_unicode(s):
+ return unicode_repr.convert_const(s)
def do_stringformat(cls, hop, sourcevarsrepr):
s_str = hop.args_s[0]
assert s_str.is_constant()
+ is_unicode = isinstance(s_str, annmodel.SomeUnicodeString)
+ if is_unicode:
+ TEMPBUF = TEMP_UNICODE
+ else:
+ TEMPBUF = TEMP
s = s_str.const
things = cls.parse_fmt_string(s)
size = inputconst(Signed, len(things)) # could be unsigned?
- cTEMP = inputconst(Void, TEMP)
+ cTEMP = inputconst(Void, TEMPBUF)
cflags = inputconst(Void, {'flavor': 'gc'})
vtemp = hop.genop("malloc_varsize", [cTEMP, cflags, size],
- resulttype=Ptr(TEMP))
+ resulttype=Ptr(TEMPBUF))
argsiter = iter(sourcevarsrepr)
@@ -979,7 +996,13 @@
vitem, r_arg = argsiter.next()
if not hasattr(r_arg, 'll_str'):
raise TyperError("ll_str unsupported for: %r" % r_arg)
- if code == 's' or (code == 'r' and isinstance(r_arg, InstanceRepr)):
+ if code == 's':
+ if is_unicode:
+ # only UniCharRepr and UnicodeRepr has it so far
+ vchunk = hop.gendirectcall(r_arg.ll_unicode, vitem)
+ else:
+ vchunk = hop.gendirectcall(r_arg.ll_str, vitem)
+ elif code == 'r' and isinstance(r_arg, InstanceRepr):
vchunk = hop.gendirectcall(r_arg.ll_str, vitem)
elif code == 'd':
assert isinstance(r_arg, IntegerRepr)
@@ -999,9 +1022,17 @@
else:
raise TyperError, "%%%s is not RPython" % (code, )
else:
- from pypy.rpython.lltypesystem.rstr import string_repr
- vchunk = inputconst(string_repr, thing)
+ from pypy.rpython.lltypesystem.rstr import string_repr, unicode_repr
+ if is_unicode:
+ vchunk = inputconst(unicode_repr, thing)
+ else:
+ vchunk = inputconst(string_repr, thing)
i = inputconst(Signed, i)
+ if is_unicode and vchunk.concretetype != Ptr(UNICODE):
+ # if we are here, one of the ll_str.* functions returned some
+ # STR, so we convert it to unicode. It's a bit suboptimal
+ # because we do one extra copy.
+ vchunk = hop.gendirectcall(cls.ll_str2unicode, vchunk)
hop.genop('setarrayitem', [vtemp, i, vchunk])
hop.exception_cannot_occur() # to ignore the ZeroDivisionError of '%'
@@ -1009,6 +1040,7 @@
do_stringformat = classmethod(do_stringformat)
TEMP = GcArray(Ptr(STR))
+TEMP_UNICODE = GcArray(Ptr(UNICODE))
# ____________________________________________________________
diff --git a/pypy/rpython/ootypesystem/ooregistry.py b/pypy/rpython/ootypesystem/ooregistry.py
--- a/pypy/rpython/ootypesystem/ooregistry.py
+++ b/pypy/rpython/ootypesystem/ooregistry.py
@@ -47,7 +47,7 @@
_type_ = ootype._string
def compute_annotation(self):
- return annmodel.SomeOOInstance(ootype=ootype.String)
+ return annmodel.SomeOOInstance(ootype=ootype.typeOf(self.instance))
class Entry_ooparse_int(ExtRegistryEntry):
diff --git a/pypy/rpython/ootypesystem/rstr.py b/pypy/rpython/ootypesystem/rstr.py
--- a/pypy/rpython/ootypesystem/rstr.py
+++ b/pypy/rpython/ootypesystem/rstr.py
@@ -1,4 +1,6 @@
from pypy.tool.pairtype import pairtype
+from pypy.annotation import model as annmodel
+from pypy.rlib.objectmodel import specialize
from pypy.rlib.rarithmetic import ovfcheck
from pypy.rpython.error import TyperError
from pypy.rpython.rstr import AbstractStringRepr,AbstractCharRepr,\
@@ -79,6 +81,12 @@
sb.ll_append_char(cast_primitive(Char, c))
return sb.ll_build()
+ def ll_unicode(self, s):
+ if s:
+ return s
+ else:
+ return self.ll.ll_constant_unicode(u'None')
+
def ll_encode_latin1(self, value):
sb = ootype.new(ootype.StringBuilder)
length = value.ll_strlen()
@@ -303,15 +311,20 @@
def ll_build_finish(buf):
return buf.ll_build()
+ @specialize.memo()
def ll_constant(s):
return ootype.make_string(s)
- ll_constant._annspecialcase_ = 'specialize:memo'
+
+ @specialize.memo()
+ def ll_constant_unicode(s):
+ return ootype.make_unicode(s)
def do_stringformat(cls, hop, sourcevarsrepr):
InstanceRepr = hop.rtyper.type_system.rclass.InstanceRepr
string_repr = hop.rtyper.type_system.rstr.string_repr
s_str = hop.args_s[0]
assert s_str.is_constant()
+ is_unicode = isinstance(s_str, annmodel.SomeUnicodeString)
s = s_str.const
c_append = hop.inputconst(ootype.Void, 'll_append')
@@ -320,8 +333,15 @@
c8 = hop.inputconst(ootype.Signed, 8)
c10 = hop.inputconst(ootype.Signed, 10)
c16 = hop.inputconst(ootype.Signed, 16)
- c_StringBuilder = hop.inputconst(ootype.Void, ootype.StringBuilder)
- v_buf = hop.genop("new", [c_StringBuilder], resulttype=ootype.StringBuilder)
+ if is_unicode:
+ StringBuilder = ootype.UnicodeBuilder
+ RESULT = ootype.Unicode
+ else:
+ StringBuilder = ootype.StringBuilder
+ RESULT = ootype.String
+
+ c_StringBuilder = hop.inputconst(ootype.Void, StringBuilder)
+ v_buf = hop.genop("new", [c_StringBuilder], resulttype=StringBuilder)
things = cls.parse_fmt_string(s)
argsiter = iter(sourcevarsrepr)
@@ -331,7 +351,12 @@
vitem, r_arg = argsiter.next()
if not hasattr(r_arg, 'll_str'):
raise TyperError("ll_str unsupported for: %r" % r_arg)
- if code == 's' or (code == 'r' and isinstance(r_arg, InstanceRepr)):
+ if code == 's':
+ if is_unicode:
+ vchunk = hop.gendirectcall(r_arg.ll_unicode, vitem)
+ else:
+ vchunk = hop.gendirectcall(r_arg.ll_str, vitem)
+ elif code == 'r' and isinstance(r_arg, InstanceRepr):
vchunk = hop.gendirectcall(r_arg.ll_str, vitem)
elif code == 'd':
assert isinstance(r_arg, IntegerRepr)
@@ -348,13 +373,19 @@
else:
raise TyperError, "%%%s is not RPython" % (code, )
else:
- vchunk = hop.inputconst(string_repr, thing)
- #i = inputconst(Signed, i)
- #hop.genop('setarrayitem', [vtemp, i, vchunk])
+ if is_unicode:
+ vchunk = hop.inputconst(unicode_repr, thing)
+ else:
+ vchunk = hop.inputconst(string_repr, thing)
+ if is_unicode and vchunk.concretetype != ootype.Unicode:
+ # if we are here, one of the ll_str.* functions returned some
+ # STR, so we convert it to unicode. It's a bit suboptimal
+ # because we do one extra copy.
+ vchunk = hop.gendirectcall(cls.ll_str2unicode, vchunk)
hop.genop('oosend', [c_append, v_buf, vchunk], resulttype=ootype.Void)
hop.exception_cannot_occur() # to ignore the ZeroDivisionError of '%'
- return hop.genop('oosend', [c_build, v_buf], resulttype=ootype.String)
+ return hop.genop('oosend', [c_build, v_buf], resulttype=RESULT)
do_stringformat = classmethod(do_stringformat)
diff --git a/pypy/rpython/rpbc.py b/pypy/rpython/rpbc.py
--- a/pypy/rpython/rpbc.py
+++ b/pypy/rpython/rpbc.py
@@ -11,7 +11,7 @@
mangle, inputdesc, warning, impossible_repr
from pypy.rpython import rclass
from pypy.rpython import robject
-from pypy.rpython.annlowlevel import llstr
+from pypy.rpython.annlowlevel import llstr, llunicode
from pypy.rpython import callparse
diff --git a/pypy/rpython/rstr.py b/pypy/rpython/rstr.py
--- a/pypy/rpython/rstr.py
+++ b/pypy/rpython/rstr.py
@@ -483,6 +483,8 @@
# xxx suboptimal, maybe
return str(unicode(ch))
+ def ll_unicode(self, ch):
+ return unicode(ch)
class __extend__(AbstractCharRepr,
AbstractUniCharRepr):
diff --git a/pypy/rpython/test/test_runicode.py b/pypy/rpython/test/test_runicode.py
--- a/pypy/rpython/test/test_runicode.py
+++ b/pypy/rpython/test/test_runicode.py
@@ -1,3 +1,4 @@
+# -*- encoding: utf-8 -*-
from pypy.rpython.lltypesystem.lltype import malloc
from pypy.rpython.lltypesystem.rstr import LLHelpers, UNICODE
@@ -194,7 +195,32 @@
assert self.interpret(fn, [u'(']) == False
assert self.interpret(fn, [u'\u1058']) == False
assert self.interpret(fn, [u'X']) == True
-
+
+ def test_strformat_unicode_arg(self):
+ const = self.const
+ def percentS(s, i):
+ s = [s, None][i]
+ return const("before %s after") % (s,)
+ #
+ res = self.interpret(percentS, [const(u'à'), 0])
+ assert self.ll_to_string(res) == const(u'before à after')
+ #
+ res = self.interpret(percentS, [const(u'à'), 1])
+ assert self.ll_to_string(res) == const(u'before None after')
+ #
+
+ def test_strformat_unicode_and_str(self):
+ # test that we correctly specialize ll_constant when we pass both a
+ # string and an unicode to it
+ const = self.const
+ def percentS(ch):
+ x = "%s" % (ch + "bc")
+ y = u"%s" % (unichr(ord(ch)) + u"bc")
+ return len(x)+len(y)
+ #
+ res = self.interpret(percentS, ["a"])
+ assert res == 6
+
def unsupported(self):
py.test.skip("not supported")
@@ -202,12 +228,6 @@
test_upper = unsupported
test_lower = unsupported
test_splitlines = unsupported
- test_strformat = unsupported
- test_strformat_instance = unsupported
- test_strformat_nontuple = unsupported
- test_percentformat_instance = unsupported
- test_percentformat_tuple = unsupported
- test_percentformat_list = unsupported
test_int = unsupported
test_int_valueerror = unsupported
test_float = unsupported
More information about the pypy-commit
mailing list