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 __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