def __init__(self, rtyper, classdef):
InstanceRepr.__init__(self, rtyper, classdef)
classdesc = classdef.classdesc
if '_virtualizable_' in classdesc.classdict:
basedesc = classdesc.basedesc
assert basedesc is None or basedesc.lookup('_virtualizable_') is None
self.top_of_virtualizable_hierarchy = True
else:
self.top_of_virtualizable_hierarchy = False
self._setters = {}
self._getters = {}
def setfield(self, vinst, attr, vvalue, llops, force_cast=False, flags={}):
"""Write the given attribute (or __class__ for the type) of 'vinst'."""
if (attr in self.my_redirected_fields
and not flags.get('access_directly')):
mangled_name, r = self.fields[attr]
if force_cast:
vinst = llops.genop('cast_pointer', [vinst], resulttype=self)
ll_setter = self.get_setter(mangled_name)
llops.gendirectcall(ll_setter, vinst, vvalue)
else:
InstanceRepr.setfield(self, vinst, attr, vvalue, llops, force_cast)
def setfield(self, vinst, attr, vvalue, llops, force_cast=False, flags={}):
"""Write the given attribute (or __class__ for the type) of 'vinst'."""
if not flags.get("access_directly") and attr in self.fields:
mangled_name, r = self.fields[attr]
if mangled_name in self.my_redirected_fields:
if force_cast:
vinst = llops.genop("cast_pointer", [vinst], resulttype=self)
c_name = inputconst(lltype.Void, mangled_name)
llops.genop("promote_virtualizable", [vinst, c_name])
llops.genop("setfield", [vinst, c_name, vvalue])
return
InstanceRepr.setfield(self, vinst, attr, vvalue, llops, force_cast)
def setfield(self, vinst, attr, vvalue, llops, force_cast=False,
flags={}):
"""Write the given attribute (or __class__ for the type) of 'vinst'."""
if (attr in self.my_redirected_fields
and not flags.get('access_directly')):
mangled_name, r = self.fields[attr]
if force_cast:
vinst = llops.genop('cast_pointer', [vinst], resulttype=self)
ll_setter = self.get_setter(mangled_name)
llops.gendirectcall(ll_setter, vinst, vvalue)
else:
InstanceRepr.setfield(self, vinst, attr, vvalue, llops, force_cast)
def __init__(self, rtyper, classdef):
InstanceRepr.__init__(self, rtyper, classdef)
classdesc = classdef.classdesc
if '_virtualizable_' in classdesc.classdict:
basedesc = classdesc.basedesc
assert basedesc is None or basedesc.lookup(
'_virtualizable_') is None
self.top_of_virtualizable_hierarchy = True
else:
self.top_of_virtualizable_hierarchy = False
self._setters = {}
self._getters = {}
def __init__(self, rtyper, classdef):
InstanceRepr.__init__(self, rtyper, classdef)
classdesc = classdef.classdesc
if "_virtualizable2_" in classdesc.classdict:
basedesc = classdesc.basedesc
assert basedesc is None or basedesc.lookup("_virtualizable2_") is None
self.top_of_virtualizable_hierarchy = True
else:
self.top_of_virtualizable_hierarchy = False
try:
self.virtuals = tuple(classdesc.classdict["_always_virtual_"].value)
except KeyError:
self.virtuals = ()
self.accessor = VirtualizableAccessor()
def _setup_repr(self):
InstanceRepr._setup_repr(self)
flds = self.allinstancefields.keys()
flds.remove('__class__')
if self.is_parent:
if flds:
raise TyperError("%r is a base class of an UnboxedValue,"
"so it cannot have fields: %r" %
(self.classdef, flds))
else:
if len(flds) != 1:
raise TyperError("%r must have exactly one field: %r" %
(self.classdef, flds))
self.specialfieldname = flds[0]
def _setup_repr(self):
InstanceRepr._setup_repr(self)
flds = self.allinstancefields.keys()
flds.remove('__class__')
if self.is_parent:
if flds:
raise TyperError("%r is a base class of an UnboxedValue,"
"so it cannot have fields: %r" % (
self.classdef, flds))
else:
if len(flds) != 1:
raise TyperError("%r must have exactly one field: %r" % (
self.classdef, flds))
self.specialfieldname = flds[0]
def _setup_repr(self):
llfields = []
ACCESS = lltype.ForwardReference()
if self.top_of_virtualizable_hierarchy:
llfields.append(('vable_base', llmemory.Address))
llfields.append(('vable_rti', VABLERTIPTR))
llfields.append(('vable_access', lltype.Ptr(ACCESS)))
InstanceRepr._setup_repr(self,
llfields,
hints={'virtualizable': True},
adtmeths={'ACCESS': ACCESS})
rbase = self.rbase
accessors = []
if self.top_of_virtualizable_hierarchy:
if len(rbase.allinstancefields) != 1:
raise TyperError("virtulizable class cannot have"
" non-virtualizable base class with instance"
" fields: %r" % self.classdef)
redirected_fields = []
else:
accessors.append(('parent', rbase.ACCESS))
redirected_fields = list(rbase.ACCESS.redirected_fields)
name = self.lowleveltype.TO._name
TOPPTR = self.get_top_virtualizable_type()
self.my_redirected_fields = my_redirected_fields = {}
for name, (mangled_name, r) in self.fields.items():
T = r.lowleveltype
if T is lltype.Void:
continue
GETTER = lltype.Ptr(lltype.FuncType([TOPPTR], T))
SETTER = lltype.Ptr(lltype.FuncType([TOPPTR, T], lltype.Void))
accessors.append(('get_' + mangled_name, GETTER))
accessors.append(('set_' + mangled_name, SETTER))
redirected_fields.append(mangled_name)
my_redirected_fields[name] = None
ACCESS.become(
lltype.Struct(
name + '_access',
hints={'immutable': True},
adtmeths={'redirected_fields': tuple(redirected_fields)},
*accessors))
self.ACCESS = ACCESS
def ll_str(self, i):
if lltype.cast_ptr_to_int(i) & 1:
from pypy.rpython.lltypesystem import rstr
from pypy.rpython.rint import signed_repr
llstr1 = signed_repr.ll_str(ll_unboxed_to_int(i))
return rstr.ll_strconcat(rstr.unboxed_instance_str_prefix,
rstr.ll_strconcat(llstr1,
rstr.unboxed_instance_str_suffix))
else:
return InstanceRepr.ll_str(self, i)
def ll_str(self, i):
if lltype.cast_ptr_to_int(i) & 1:
from pypy.rpython.lltypesystem import rstr
from pypy.rpython.rint import signed_repr
llstr1 = signed_repr.ll_str(ll_unboxed_to_int(i))
return rstr.ll_strconcat(
rstr.unboxed_instance_str_prefix,
rstr.ll_strconcat(llstr1, rstr.unboxed_instance_str_suffix))
else:
return InstanceRepr.ll_str(self, i)
def _setup_repr(self):
llfields = []
if self.top_of_virtualizable_hierarchy:
llfields.append(("vable_base", llmemory.Address))
llfields.append(("vable_rti", VABLERTIPTR))
InstanceRepr._setup_repr(
self,
llfields,
hints={"virtualizable2": True, "virtuals": self.virtuals},
adtmeths={"access": self.accessor},
)
my_redirected_fields = []
for _, (mangled_name, _) in self.fields.items():
my_redirected_fields.append(mangled_name)
self.my_redirected_fields = dict.fromkeys(my_redirected_fields)
if self.top_of_virtualizable_hierarchy:
self.accessor.initialize(self.object_type, my_redirected_fields)
else:
self.accessor.initialize(self.object_type, my_redirected_fields, self.rbase.lowleveltype.TO)
def _setup_repr(self):
llfields = []
ACCESS = lltype.ForwardReference()
if self.top_of_virtualizable_hierarchy:
llfields.append(('vable_base', llmemory.Address))
llfields.append(('vable_rti', VABLERTIPTR))
llfields.append(('vable_access', lltype.Ptr(ACCESS)))
InstanceRepr._setup_repr(self, llfields,
hints = {'virtualizable': True},
adtmeths = {'ACCESS': ACCESS})
rbase = self.rbase
accessors = []
if self.top_of_virtualizable_hierarchy:
if len(rbase.allinstancefields) != 1:
raise TyperError("virtulizable class cannot have"
" non-virtualizable base class with instance"
" fields: %r" % self.classdef)
redirected_fields = []
else:
accessors.append(('parent', rbase.ACCESS))
redirected_fields = list(rbase.ACCESS.redirected_fields)
name = self.lowleveltype.TO._name
TOPPTR = self.get_top_virtualizable_type()
self.my_redirected_fields = my_redirected_fields = {}
for name, (mangled_name, r) in self.fields.items():
T = r.lowleveltype
if T is lltype.Void:
continue
GETTER = lltype.Ptr(lltype.FuncType([TOPPTR], T))
SETTER = lltype.Ptr(lltype.FuncType([TOPPTR, T], lltype.Void))
accessors.append(('get_'+mangled_name, GETTER))
accessors.append(('set_'+mangled_name, SETTER))
redirected_fields.append(mangled_name)
my_redirected_fields[name] = None
ACCESS.become(lltype.Struct(name+'_access',
hints = {'immutable': True},
adtmeths = {'redirected_fields': tuple(redirected_fields)},
*accessors))
self.ACCESS = ACCESS
def __init__(self, rtyper, classdef, unboxedclassdef):
InstanceRepr.__init__(self, rtyper, classdef)
self.unboxedclassdef = unboxedclassdef
self.is_parent = unboxedclassdef is not classdef
def new_instance(self, llops, classcallhop=None, v_cpytype=None):
vptr = InstanceRepr.new_instance(self, llops, classcallhop, v_cpytype)
self.set_vable(llops, vptr)
return vptr
def new_instance(self, llops, classcallhop=None):
vptr = InstanceRepr.new_instance(self, llops, classcallhop)
self.set_vable(llops, vptr)
return vptr
def __init__(self, rtyper, classdef, unboxedclassdef):
InstanceRepr.__init__(self, rtyper, classdef)
self.unboxedclassdef = unboxedclassdef
self.is_parent = unboxedclassdef is not classdef
