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 default_specialize(funcdesc, args_s):
# first flatten the *args
args_s, key, builder = flatten_star_args(funcdesc, args_s)
# two versions: a regular one and one for instances with 'access_directly'
jit_look_inside = getattr(funcdesc.pyobj, '_jit_look_inside_', True)
# change args_s in place, "official" interface
access_directly = False
for i, s_obj in enumerate(args_s):
if (isinstance(s_obj, annmodel.SomeInstance)
and 'access_directly' in s_obj.flags):
if jit_look_inside:
access_directly = True
key = (AccessDirect, key)
break
else:
new_flags = s_obj.flags.copy()
del new_flags['access_directly']
new_s_obj = annmodel.SomeInstance(s_obj.classdef,
s_obj.can_be_None,
flags=new_flags)
args_s[i] = new_s_obj
# done
graph = funcdesc.cachedgraph(key, builder=builder)
if access_directly:
graph.access_directly = True
return graph
def __init__(self, rtyper, s_pbc):
self.rtyper = rtyper
self.s_pbc = s_pbc
mdescs = list(s_pbc.descriptions)
methodname = mdescs[0].name
classdef = mdescs[0].selfclassdef
flags = mdescs[0].flags
for mdesc in mdescs[1:]:
if mdesc.name != methodname:
raise TyperError("cannot find a unique name under which the "
"methods can be found: %r" % (mdescs, ))
if mdesc.flags != flags:
raise TyperError("inconsistent 'flags': %r versus %r" %
(mdesc.flags, flags))
classdef = classdef.commonbase(mdesc.selfclassdef)
if classdef is None:
raise TyperError("mixing methods coming from instances of "
"classes with no common base: %r" %
(mdescs, ))
self.methodname = methodname
self.classdef = classdef.get_owner(methodname)
# the low-level representation is just the bound 'self' argument.
self.s_im_self = annmodel.SomeInstance(self.classdef, flags=flags)
self.r_im_self = rclass.getinstancerepr(rtyper, self.classdef)
self.lowleveltype = self.r_im_self.lowleveltype
def compute_result_annotation(self, s_Class, s_ob):
from rpython.annotator import model as annmodel
from rpython.rtyper.llannotation import SomePtr
assert isinstance(s_ob, SomePtr)
assert s_Class.is_constant()
classdef = self.bookkeeper.getuniqueclassdef(s_Class.const)
return annmodel.SomeInstance(classdef, can_be_None=True)
def create_instantiate_function(annotator, classdef):
# build the graph of a function that looks like
#
# def my_instantiate():
# return instantiate(cls)
#
if hasattr(classdef, 'my_instantiate_graph'):
return
v = Variable()
block = Block([])
block.operations.append(SpaceOperation('instantiate1', [], v))
name = valid_identifier('instantiate_' + classdef.name)
graph = FunctionGraph(name, block)
block.closeblock(Link([v], graph.returnblock))
annotator.setbinding(v, annmodel.SomeInstance(classdef))
annotator.annotated[block] = graph
# force the result to be converted to a generic OBJECTPTR
generalizedresult = annmodel.SomeInstance(classdef=None)
annotator.setbinding(graph.getreturnvar(), generalizedresult)
classdef.my_instantiate_graph = graph
annotator.translator.graphs.append(graph)
def compute_result_annotation(self, s_x, **kwds_s):
from rpython.annotator import model as annmodel
s_x = annmodel.not_const(s_x)
access_directly = 's_access_directly' in kwds_s
fresh_virtualizable = 's_fresh_virtualizable' in kwds_s
if access_directly or fresh_virtualizable:
assert access_directly, "lone fresh_virtualizable hint"
if isinstance(s_x, annmodel.SomeInstance):
from rpython.flowspace.model import Constant
classdesc = s_x.classdef.classdesc
virtualizable = classdesc.read_attribute(
'_virtualizable_', Constant(None)).value
if virtualizable is not None:
flags = s_x.flags.copy()
flags['access_directly'] = True
if fresh_virtualizable:
flags['fresh_virtualizable'] = True
s_x = annmodel.SomeInstance(s_x.classdef, s_x.can_be_None,
flags)
return s_x
def cutoff_alwaysraising_block(self, block):
"Fix a block whose end can never be reached at run-time."
# search the operation that cannot succeed
can_succeed = [
op for op in block.operations if op.result.annotation is not None
]
cannot_succeed = [
op for op in block.operations if op.result.annotation is None
]
n = len(can_succeed)
# check consistency
assert can_succeed == block.operations[:n]
assert cannot_succeed == block.operations[n:]
assert 0 <= n < len(block.operations)
# chop off the unreachable end of the block
del block.operations[n + 1:]
self.setbinding(block.operations[n].result, annmodel.s_ImpossibleValue)
# insert the equivalent of 'raise AssertionError'
graph = self.annotated[block]
msg = "Call to %r should have raised an exception" % (getattr(
graph, 'func', None), )
c1 = Constant(AssertionError)
c2 = Constant(AssertionError(msg))
errlink = Link([c1, c2], graph.exceptblock)
block.recloseblock(errlink, *block.exits)
# record new link to make the transformation idempotent
self.links_followed[errlink] = True
# fix the annotation of the exceptblock.inputargs
etype, evalue = graph.exceptblock.inputargs
s_type = annmodel.SomeType()
s_type.is_type_of = [evalue]
s_value = annmodel.SomeInstance(
self.bookkeeper.getuniqueclassdef(Exception))
self.setbinding(etype, s_type)
self.setbinding(evalue, s_value)
# make sure the bookkeeper knows about AssertionError
self.bookkeeper.getuniqueclassdef(AssertionError)
def instance(cls):
return lambda bookkeeper: model.SomeInstance(
bookkeeper.getuniqueclassdef(cls))
def compute_result_annotation(self, s_Class, s_ptr):
assert s_Class.is_constant()
classdef = self.bookkeeper.getuniqueclassdef(s_Class.const)
return annmodel.SomeInstance(classdef, can_be_None=True)
def s_r_instanceof(self, cls, can_be_None=True, check_never_seen=True):
classdesc = self.rtyper.annotator.bookkeeper.getdesc(cls)
classdef = classdesc.getuniqueclassdef()
s_instance = annmodel.SomeInstance(classdef, can_be_None)
r_instance = self.getdelayedrepr(s_instance, check_never_seen)
return s_instance, r_instance
def instance(cls, can_be_None=False):
return lambda bookkeeper: model.SomeInstance(
bookkeeper.getuniqueclassdef(cls), can_be_None=can_be_None)
def method_get(self, s_key):
assert isinstance(s_key, annmodel.SomeInstance)
assert s_key.classdef.issubclass(self.keyclassdef)
return annmodel.SomeInstance(self.valueclassdef, can_be_None=True)
def method_get(self, s_key):
return annmodel.SomeInstance(self.valueclassdef, can_be_None=True)
