def method_matches(self, s_s, s_pos): assert model.SomeString().contains(s_s) assert model.SomeInteger(nonneg=True).contains(s_pos) bk = getbookkeeper() init_pbc = bk.immutablevalue(Match.__init__) bk.emulate_pbc_call((self, "match_init"), init_pbc, [ model.SomeInstance(bk.getuniqueclassdef(Match)), model.SomeInteger(nonneg=True), model.SomeInteger(nonneg=True) ]) init_pbc = bk.immutablevalue(rsre_core.StrMatchContext.__init__) bk.emulate_pbc_call((self, "str_match_context_init"), init_pbc, [ model.SomeInstance( bk.getuniqueclassdef(rsre_core.StrMatchContext)), bk.newlist(model.SomeInteger(nonneg=True)), model.SomeString(), model.SomeInteger(nonneg=True), model.SomeInteger(nonneg=True), model.SomeInteger(nonneg=True), ]) match_context_pbc = bk.immutablevalue(rsre_core.match_context) bk.emulate_pbc_call((self, "match_context"), match_context_pbc, [ model.SomeInstance( bk.getuniqueclassdef(rsre_core.StrMatchContext)), ]) return model.SomeInstance(getbookkeeper().getuniqueclassdef(Match), can_be_None=True)
def test_return(): @signature(returns=types.str()) def f(): return 'a' assert getsig(f) == [model.SomeString()] @signature(types.str(), returns=types.str()) def f(x): return x def g(): return f('a') a = annotate_at(g) assert sigof(a, f) == [model.SomeString(), model.SomeString()]
def make_driverhook_graphs(self): # annhelper = MixLevelHelperAnnotator(self.translator.rtyper) for jd in self.jitdrivers_sd: jd._get_printable_location_ptr = self._make_hook_graph( jd, annhelper, jd.jitdriver.get_printable_location, annmodel.SomeString()) jd._get_unique_id_ptr = self._make_hook_graph( jd, annhelper, jd.jitdriver.get_unique_id, annmodel.SomeInteger()) jd._confirm_enter_jit_ptr = self._make_hook_graph( jd, annhelper, jd.jitdriver.confirm_enter_jit, annmodel.s_Bool, onlygreens=False) jd._can_never_inline_ptr = self._make_hook_graph( jd, annhelper, jd.jitdriver.can_never_inline, annmodel.s_Bool) jd._should_unroll_one_iteration_ptr = self._make_hook_graph( jd, annhelper, jd.jitdriver.should_unroll_one_iteration, annmodel.s_Bool) # items = [] types = () pos = () if jd.jitdriver.get_location: assert hasattr(jd.jitdriver.get_location, '_loc_types'), """ You must decorate your get_location function: from rpython.rlib.rjitlog import rjitlog as jl @jl.returns(jl.MP_FILENAME, jl.MP_XXX, ...) def get_loc(your, green, keys): name = "x.txt" # extract it from your green keys return (name, ...) """ types = jd.jitdriver.get_location._loc_types del jd.jitdriver.get_location._loc_types # for _, type in types: if type == 's': items.append(annmodel.SomeString()) elif type == 'i': items.append(annmodel.SomeInteger()) else: raise NotImplementedError s_Tuple = annmodel.SomeTuple(items) jd._get_location_ptr = self._make_hook_graph( jd, annhelper, jd.jitdriver.get_location, s_Tuple) jd._get_loc_types = types annhelper.finish()
def default_arguments(self): from rpython.annotator import model as annmodel from rpython.rtyper import llannotation return [ llannotation.SomePtr(ll_ptrtype=_CMDPTR), annmodel.SomeString() ]
def test_dict(): @signature(returns=types.dict(types.str(), types.int())) def f(): return {'a': 1, 'b': 2} rettype = getsig(f)[0] assert isinstance(rettype, model.SomeDict) assert rettype.dictdef.dictkey.s_value == model.SomeString() assert rettype.dictdef.dictvalue.s_value == model.SomeInteger()
def compute_result_annotation(self, s_driver, s_name, s_value): from rpython.annotator import model as annmodel assert s_name.is_constant() if s_name.const == 'enable_opts': assert annmodel.SomeString(can_be_None=True).contains(s_value) else: assert (s_value == annmodel.s_None or annmodel.SomeInteger().contains(s_value)) return annmodel.s_None
def test_str0(): @signature(types.unicode0(), returns=types.str0()) def f(u): return 'str' assert getsig(f) == [ model.SomeUnicodeString(no_nul=True), model.SomeString(no_nul=True) ]
def test_nullstring(): def oof(b): if b: return 'foo' else: return None a = RPythonAnnotator() s = a.build_types(oof, [bool]) assert annmodel.SomeString(can_be_None=True).contains(s)
def test_basic(): @signature(types.int(), types.str(), returns=types.char()) def f(a, b): return b[a] assert getsig(f) == [ model.SomeInteger(), model.SomeString(), model.SomeChar() ]
class scoped_str2charp: def __init__(self, value): if value is not None: self.buf = str2charp(value) else: self.buf = lltype.nullptr(CCHARP.TO) __init__._annenforceargs_ = [None, annmodel.SomeString(can_be_None=True)] def __enter__(self): return self.buf def __exit__(self, *args): if self.buf: free_charp(self.buf)
def make_driverhook_graphs(self): s_Str = annmodel.SomeString() # annhelper = MixLevelHelperAnnotator(self.translator.rtyper) for jd in self.jitdrivers_sd: jd._get_printable_location_ptr = self._make_hook_graph(jd, annhelper, jd.jitdriver.get_printable_location, s_Str) jd._confirm_enter_jit_ptr = self._make_hook_graph(jd, annhelper, jd.jitdriver.confirm_enter_jit, annmodel.s_Bool, onlygreens=False) jd._can_never_inline_ptr = self._make_hook_graph(jd, annhelper, jd.jitdriver.can_never_inline, annmodel.s_Bool) jd._should_unroll_one_iteration_ptr = self._make_hook_graph(jd, annhelper, jd.jitdriver.should_unroll_one_iteration, annmodel.s_Bool) annhelper.finish()
def test_list_of_str0(self): str0 = annmodel.SomeString(no_nul=True) def os_execve(l): pass register_external(os_execve, [[str0]], None) def f(l): return os_execve(l) policy = AnnotatorPolicy() a = RPythonAnnotator(policy=policy) a.build_types(f, [[str]]) # Does not raise assert a.translator.config.translation.check_str_without_nul == False # Now enable the str0 check, and try again with a similar function a.translator.config.translation.check_str_without_nul=True def g(l): return os_execve(l) py.test.raises(Exception, a.build_types, g, [[str]]) a.build_types(g, [[str0]]) # Does not raise
def stress_combination(self, key_can_be_none, value_can_be_none): from rpython.rtyper.lltypesystem.rstr import string_repr from rpython.annotator.dictdef import DictKey, DictValue from rpython.annotator import model as annmodel from rpython.rtyper.test.test_rdict import not_really_random rodct = rordereddict print print "Testing combination with can_be_None: keys %s, values %s" % ( key_can_be_none, value_can_be_none) class PseudoRTyper: cache_dummy_values = {} dictrepr = rodct.OrderedDictRepr( PseudoRTyper(), string_repr, string_repr, DictKey(None, annmodel.SomeString(key_can_be_none)), DictValue(None, annmodel.SomeString(value_can_be_none))) dictrepr.setup() print dictrepr.lowleveltype #for key, value in dictrepr.DICTENTRY._adtmeths.items(): # print ' %s = %s' % (key, value) l_dict = rodct.ll_newdict(dictrepr.DICT) referencetable = [None] * 400 referencelength = 0 values = not_really_random() keytable = [ string_repr.convert_const("foo%d" % n) for n in range(len(referencetable)) ] def complete_check(): for n, refvalue in zip(range(len(referencetable)), referencetable): try: gotvalue = rodct.ll_dict_getitem(l_dict, keytable[n]) except KeyError: assert refvalue is None else: assert gotvalue == refvalue for x in not_really_random(): n = int(x * 100.0) # 0 <= x < 400 op = repr(x)[-1] if op <= '2' and referencetable[n] is not None: rodct.ll_dict_delitem(l_dict, keytable[n]) referencetable[n] = None referencelength -= 1 elif op <= '6': ll_value = string_repr.convert_const(str(values.next())) rodct.ll_dict_setitem(l_dict, keytable[n], ll_value) if referencetable[n] is None: referencelength += 1 referencetable[n] = ll_value else: try: gotvalue = rodct.ll_dict_getitem(l_dict, keytable[n]) except KeyError: assert referencetable[n] is None else: assert gotvalue == referencetable[n] if 1.38 <= x <= 1.39: complete_check() print 'current dict length:', referencelength assert l_dict.num_live_items == referencelength complete_check()
return rstring_to_float(s) add_loader(annmodel.SomeFloat(), load_float) def dump_string_or_none(buf, x): if x is None: dump_none(buf, x) else: buf.append(TYPE_STRING) w_long(buf, len(x)) buf += x add_dumper(annmodel.SomeString(can_be_None=True), dump_string_or_none) def load_single_char(loader): if readchr(loader) != TYPE_STRING or readlong(loader) != 1: raise ValueError("expected a character") return readchr(loader) add_loader(annmodel.SomeChar(), load_single_char) def load_string_nonul(loader): if readchr(loader) != TYPE_STRING: raise ValueError("expected a string") length = readlong(loader)
import py import marshal from rpython.rlib.rmarshal import * from rpython.annotator import model as annmodel from rpython.rlib.rarithmetic import LONG_BIT from rpython.rlib.rfloat import formatd types_that_can_be_none = [ [int], annmodel.SomeString(can_be_None=True), annmodel.s_None, { int: int }, ] def test_marshaller(): buf = [] get_marshaller(int)(buf, 5) assert marshal.loads(''.join(buf)) == 5 buf = [] get_marshaller(int)(buf, -555) assert marshal.loads(''.join(buf)) == -555 buf = [] get_marshaller(float)(buf, 3.25) assert marshal.loads(''.join(buf)) == 3.25 buf = []
def compute_result_annotation(self, s_ll_str): if strtype is str: return annmodel.SomeString(can_be_None=True) else: return annmodel.SomeUnicodeString(can_be_None=True)
def str(can_be_None=False): return model.SomeString(can_be_None=can_be_None)
def str0(): return model.SomeString(no_nul=True)
def test_reprkeys_dont_clash(): stup1 = annmodel.SomeTuple((annmodel.SomeFloat(), annmodel.SomeInteger())) stup2 = annmodel.SomeTuple((annmodel.SomeString(), annmodel.SomeInteger())) key1 = stup1.rtyper_makekey() key2 = stup2.rtyper_makekey() assert key1 != key2
from rpython.jit.metainterp.history import ResOperation args = [_cast_to_box(llargs[i]) for i in range(len(llargs))] if llres: res = _cast_to_box(llres) else: res = None return _cast_to_gcref(ResOperation(no, args, res)) @register_helper(annmodel.SomeInteger()) def resop_getopnum(llop): return _cast_to_resop(llop).getopnum() @register_helper(annmodel.SomeString(can_be_None=True)) def resop_getopname(llop): return llstr(_cast_to_resop(llop).getopname()) @register_helper(SomePtr(llmemory.GCREF)) def resop_getarg(llop, no): return _cast_to_gcref(_cast_to_resop(llop).getarg(no)) @register_helper(annmodel.s_None) def resop_setarg(llop, no, llbox): _cast_to_resop(llop).setarg(no, _cast_to_box(llbox)) @register_helper(annmodel.SomeInteger())
def getattr(self, s_attr): if s_attr.is_constant() and s_attr.const == "name": return model.SomeString() return super(SomeRule, self).getattr(s_attr)