def test_subclassof(self): A = ootype.Instance("A", ootype.ROOT) B = ootype.Instance("B", A) clsA = ootype.runtimeClass(A) clsB = ootype.runtimeClass(B) myjitdriver = JitDriver(greens=[], reds=['n', 'flag', 'res']) def getcls(flag): if flag: return clsA else: return clsB def f(flag, n): res = True while n > -100: myjitdriver.can_enter_jit(n=n, flag=flag, res=res) myjitdriver.jit_merge_point(n=n, flag=flag, res=res) cls = getcls(flag) n -= 1 res = ootype.subclassof(cls, clsB) return res res = self.meta_interp(f, [1, 100], policy=StopAtXPolicy(getcls), optimizer=OPTIMIZER_SIMPLE) assert not res res = self.meta_interp(f, [0, 100], policy=StopAtXPolicy(getcls), optimizer=OPTIMIZER_SIMPLE) assert res
def test_fielddescr_ootype(): from pypy.rpython.ootypesystem import ootype from pypy.jit.backend.cli.runner import CliCPU A = ootype.Instance("A", ootype.ROOT, {"foo": ootype.Signed}) B = ootype.Instance("B", A) descr1 = CliCPU.fielddescrof(A, "foo") descr2 = CliCPU.fielddescrof(B, "foo") assert descr1 is descr2
def test_fielddescr_ootype(): from pypy.rpython.ootypesystem import ootype from pypy.jit.backend.llgraph.runner import OOtypeCPU A = ootype.Instance("A", ootype.ROOT, {"foo": ootype.Signed}) B = ootype.Instance("B", A) cpu = OOtypeCPU(None) descr1 = cpu.fielddescrof(A, "foo") descr2 = cpu.fielddescrof(B, "foo") assert descr1 is descr2
def test_oostring_instance(self): A = ootype.Instance("A", ootype.ROOT) B = ootype.Instance("B", ootype.ROOT) def f(n): obj1 = ootype.new(A) obj2 = ootype.new(B) s1 = ootype.oostring(obj1, -1) s2 = ootype.oostring(obj2, -1) ch1 = s1.ll_stritem_nonneg(1) ch2 = s2.ll_stritem_nonneg(1) return ord(ch1) + ord(ch2) res = self.interp_operations(f, [0]) assert res == ord('A') + ord('B')
def __init__(self, rtyper, classdef, gcflavor='ignored'): AbstractInstanceRepr.__init__(self, rtyper, classdef) self.baserepr = None if self.classdef is None: self.lowleveltype = OBJECT else: b = self.classdef.basedef if b is not None: self.baserepr = getinstancerepr(rtyper, b) b = self.baserepr.lowleveltype else: b = OBJECT if hasattr(classdef.classdesc.pyobj, '_rpython_hints'): hints = classdef.classdesc.pyobj._rpython_hints else: hints = {} hints = self._check_for_immutable_hints(hints) self.lowleveltype = ootype.Instance(classdef.name, b, {}, {}, _hints=hints) self.iprebuiltinstances = identity_dict() self.object_type = self.lowleveltype self.gcflavor = gcflavor
def __init__(self, rtyper, access_set): self.rtyper = rtyper self.access_set = access_set self.lowleveltype = ootype.Instance('pbc', PBCROOT, _hints={'immutable': True}) self.pbc_cache = {}
def __init__(self, rtyper, classdef): AbstractClassRepr.__init__(self, rtyper, classdef) # This is the Repr for a reference to the class 'classdef' or # any subclass. In the simple case, the lowleveltype is just # ootype.Class. If we need to store class attributes, we use a # "meta" class where the attributes are defined, and the class # reference is a reference to an instance of this meta class. extra_access_sets = self.rtyper.class_pbc_attributes.get(classdef, {}) has_class_attributes = bool(extra_access_sets) if self.classdef is not None: self.rbase = getclassrepr(self.rtyper, self.classdef.basedef) meta_base_type = self.rbase.lowleveltype baseclass_has_meta = meta_base_type != ootype.Class else: baseclass_has_meta = False if not has_class_attributes and not baseclass_has_meta: self.lowleveltype = ootype.Class # simple case else: if self.classdef is None: raise TyperError("the root 'object' class should not have" " class attributes") if self.classdef.classdesc.pyobj in standardexceptions: raise TyperError("Standard exception class %r should not have" " class attributes" % (self.classdef.name, )) if not baseclass_has_meta: meta_base_type = META self.lowleveltype = ootype.Instance(self.classdef.name + "_meta", meta_base_type)
def test_oohelper(): S = ootype.Instance('S', ootype.ROOT, {'x': Signed, 'y': Signed}) def f(s, z): #assert we_are_translated() return s.x * s.y + z def g(s): #assert we_are_translated() return s.x + s.y F = ootype.StaticMethod([S, Signed], Signed) G = ootype.StaticMethod([S], Signed) def h(x, y, z): s = ootype.new(S) s.x = x s.y = y fsm = llhelper(F, f) gsm = llhelper(G, g) assert typeOf(fsm) == F return fsm(s, z) + fsm(s, z * 2) + gsm(s) res = h(8, 5, 2) assert res == 99 res = interpret(h, [8, 5, 2], type_system='ootype') assert res == 99
def test_oononnull(self): FOO = ootype.Instance('Foo', ootype.ROOT) def fn(): s = ootype.new(FOO) return bool(s) self.check(fn, [], [], True)
def test_compare_classes(): A = ootype.Instance("A", ootype.ROOT) B = ootype.Instance("B", ootype.ROOT) cls1 = ootype.runtimeClass(A) def fn(n): if n: cls2 = ootype.runtimeClass(A) else: cls2 = ootype.runtimeClass(B) assert (cls1 == cls2) == (not (cls1 != cls2)) return cls1 == cls2 res = interpret(fn, [1], type_system='ootype') assert res
def test_box_unbox_ooinstance_fail(self): A = ootype.Instance('A', ootype.ROOT, {'xx': ootype.Signed}) def fn(flag): b_obj = System.Object() a2 = unbox(b_obj, A) return a2 res = self.interpret(fn, [True]) assert res is None
def test_filter_out_instance_with_void(): effects = frozenset([("struct", ootype.Instance("x", ootype.ROOT, {"a": ootype.Void}), "a")]) effectinfo = effectinfo_from_writeanalyze(effects, None) assert not effectinfo.readonly_descrs_fields assert not effectinfo.write_descrs_fields assert not effectinfo.write_descrs_arrays
def test_box_unbox_ooinstance(self): A = ootype.Instance('A', ootype.ROOT, {'xx': ootype.Signed}) def fn(flag): a = ootype.new(A) a.xx = 42 b_obj = box(a) a2 = unbox(b_obj, A) return a2.xx res = self.interpret(fn, [True]) assert res == 42
def test_identityhash(self): A = ootype.Instance("A", ootype.ROOT) def f(): obj1 = ootype.new(A) obj2 = ootype.new(A) return ootype.identityhash(obj1) == ootype.identityhash(obj2) assert not f() res = self.interp_operations(f, []) assert not res
def __init__(self, rtyper, classdef): AbstractClassRepr.__init__(self, rtyper, classdef) if self.classdef is not None: self.rbase = getclassrepr(self.rtyper, self.classdef.basedef) base_type = self.rbase.lowleveltype self.lowleveltype = ootype.Instance(self.classdef.name + "_meta", base_type) else: # we are ROOT self.lowleveltype = CLASSTYPE
def test_cast_object_instance(self): A = ootype.Instance("Foo", ootype.ROOT) def fn_instance(): a = ootype.new(A) obj = ootype.cast_to_object(a) a2 = ootype.cast_from_object(A, obj) a3 = ootype.cast_from_object(ootype.ROOT, obj) assert a is a2 assert a is a3 self.interpret(fn_instance, [])
def test_cast_object_mix_null(self): A = ootype.Instance("Foo", ootype.ROOT) def fn_mix_null(flag): a = ootype.new(A) obj = ootype.cast_to_object(a) if flag: return obj else: return ootype.NULL res = self.interpret(fn_mix_null, [False]) assert res is ootype.NULL
def test_cast_object_is_true(self): A = ootype.Instance("Foo", ootype.ROOT) def fn_is_true(flag): if flag: a = ootype.new(A) else: a = ootype.null(A) obj = ootype.cast_to_object(a) return bool(obj) assert self.interpret(fn_is_true, [True]) is True assert self.interpret(fn_is_true, [False]) is False
def test_cast_object_null(self): A = ootype.Instance("Foo", ootype.ROOT) B = ootype.Record({'x': ootype.Signed}) def fn_null(): a = ootype.null(A) b = ootype.null(B) obj1 = ootype.cast_to_object(a) obj2 = ootype.cast_to_object(b) assert obj1 == obj2 assert ootype.cast_from_object(A, obj1) == a assert ootype.cast_from_object(B, obj2) == b self.interpret(fn_null, [])
def test_fieldinfo_for_const_pbc(self): A = ootype.Instance('A', ootype.ROOT, {'xx': ootype.Signed}) const = ootype.new(A) fieldinfo = fieldinfo_for_const(const) def fn(): const.xx = 42 obj = fieldinfo.GetValue(None) # get the 'xx' field by using reflection t = obj.GetType() x_info = t.GetField('xx') x_value = x_info.GetValue(obj) return unbox(x_value, ootype.Signed) res = self.interpret(fn, []) assert res == 42
def test_cast_native_object(self): A = ootype.Instance("A", ootype.ROOT, {}) def fn(): a = ootype.new(A) ahash = ootype.identityhash(a) obj = ootype.cast_to_object(a) native = cast_to_native_object(obj) name = native.GetType().get_Name() obj2 = cast_from_native_object(native) a2 = ootype.cast_from_object(A, obj2) a2hash = ootype.identityhash(a2) return name, ahash == a2hash res = self.ll_to_tuple(self.interpret(fn, [])) assert res == ('A', True)
def test_oois(self): A = ootype.Instance("A", ootype.ROOT) def f(n): obj1 = ootype.new(A) if n: obj2 = obj1 else: obj2 = ootype.new(A) return obj1 is obj2 res = self.interp_operations(f, [0]) assert not res res = self.interp_operations(f, [1]) assert res
def test_unwrap_object(self): A = ootype.Instance("A", ootype.ROOT, {}) a1 = ootype.new(A) a2 = ootype.new(A) obj1 = ootype.cast_to_object(a1) obj2 = ootype.cast_to_object(a2) def fn(flag): if flag: obj = obj1 else: obj = obj2 a3 = ootype.cast_from_object(A, obj) return a3 is a1 res = self.interpret(fn, [True], backendopt=False) assert res is True
def __init__(self, rtyper, classdef, gcflavor='ignored'): AbstractInstanceRepr.__init__(self, rtyper, classdef) self.baserepr = None if self.classdef is None: self.lowleveltype = OBJECT else: b = self.classdef.basedef if b is not None: self.baserepr = getinstancerepr(rtyper, b) b = self.baserepr.lowleveltype else: b = OBJECT if hasattr(classdef.classdesc.pyobj, '_rpython_hints'): hints = classdef.classdesc.pyobj._rpython_hints else: hints = {} self.lowleveltype = ootype.Instance(classdef.name, b, {}, {}, _hints=hints) self.prebuiltinstances = {} # { id(x): (x, _ptr) } self.object_type = self.lowleveltype self.gcflavor = gcflavor
class OOtypeMixin(object): type_system = 'ootype' def get_class_of_box(self, box): root = box.getref(ootype.ROOT) return ootype.classof(root) cpu = runner.OOtypeCPU(None) NODE = ootype.Instance('NODE', ootype.ROOT, {}) NODE._add_fields({'value': ootype.Signed, 'floatval' : ootype.Float, 'next': NODE}) NODE2 = ootype.Instance('NODE2', NODE, {'other': NODE}) node_vtable = ootype.runtimeClass(NODE) node_vtable_adr = ootype.cast_to_object(node_vtable) node_vtable2 = ootype.runtimeClass(NODE2) node_vtable_adr2 = ootype.cast_to_object(node_vtable2) node = ootype.new(NODE) nodebox = BoxObj(ootype.cast_to_object(node)) myptr = nodebox.value myptr2 = ootype.cast_to_object(ootype.new(NODE)) nodebox2 = BoxObj(ootype.cast_to_object(node)) valuedescr = cpu.fielddescrof(NODE, 'value') floatdescr = cpu.fielddescrof(NODE, 'floatval') nextdescr = cpu.fielddescrof(NODE, 'next') otherdescr = cpu.fielddescrof(NODE2, 'other') nodesize = cpu.typedescrof(NODE) nodesize2 = cpu.typedescrof(NODE2) arraydescr = cpu.arraydescrof(ootype.Array(ootype.Signed)) floatarraydescr = cpu.arraydescrof(ootype.Array(ootype.Float)) # a plain Record S = ootype.Record({'a': ootype.Signed, 'b': NODE}) ssize = cpu.typedescrof(S) adescr = cpu.fielddescrof(S, 'a') bdescr = cpu.fielddescrof(S, 'b') sbox = BoxObj(ootype.cast_to_object(ootype.new(S))) arraydescr2 = cpu.arraydescrof(ootype.Array(S)) T = ootype.Record({'c': ootype.Signed, 'd': ootype.Array(NODE)}) tsize = cpu.typedescrof(T) cdescr = cpu.fielddescrof(T, 'c') ddescr = cpu.fielddescrof(T, 'd') arraydescr3 = cpu.arraydescrof(ootype.Array(NODE)) U = ootype.Instance('U', ootype.ROOT, {'one': ootype.Array(NODE)}) usize = cpu.typedescrof(U) onedescr = cpu.fielddescrof(U, 'one') u_vtable = ootype.runtimeClass(U) u_vtable_adr = ootype.cast_to_object(u_vtable) # force a consistent order valuedescr.sort_key() nextdescr.sort_key() adescr.sort_key() bdescr.sort_key() FUNC = lltype.FuncType([lltype.Signed], lltype.Signed) nonwritedescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT) # XXX fix ootype cpu.class_sizes = {node_vtable_adr: cpu.typedescrof(NODE), node_vtable_adr2: cpu.typedescrof(NODE2), u_vtable_adr: cpu.typedescrof(U)} namespace = locals()
from pypy.rpython.rslice import AbstractSliceRepr from pypy.rpython.lltypesystem.lltype import Void, Signed from pypy.rpython.ootypesystem import ootype SLICE = ootype.Instance('Slice', ootype.ROOT, { 'start': Signed, 'stop': Signed }) class SliceRepr(AbstractSliceRepr): pass startstop_slice_repr = SliceRepr() startstop_slice_repr.lowleveltype = SLICE startonly_slice_repr = SliceRepr() startonly_slice_repr.lowleveltype = Signed minusone_slice_repr = SliceRepr() minusone_slice_repr.lowleveltype = Void # only for [:-1] # ____________________________________________________________ def ll_newslice(start, stop): s = ootype.new(SLICE) s.start = start s.stop = stop return s
def _get_NODE(self): NODE = ootype.Instance('NODE', ootype.ROOT, {}) NODE._add_fields({'value': ootype.Signed, 'next': NODE}) return NODE
def GcStruct(name, *fields, **kwds): if 'hints' in kwds: kwds['_hints'] = kwds['hints'] del kwds['hints'] I = ootype.Instance(name, ootype.ROOT, dict(fields), **kwds) return I
def _get_method_name(self, opname, s_pbc, args_s, hop): shape, index, callfamily = self._get_shape_index_callfamily(opname, s_pbc, args_s, hop) mangled = mangle(self.methodname, self.rtyper.getconfig()) row = self.concretetable[shape, index] derived_mangled = row_method_name(mangled, row.attrname) return derived_mangled class __extend__(pairtype(InstanceRepr, MethodsPBCRepr)): def convert_from_to(_, v, llops): return v # ____________________________________________________________ PBCROOT = ootype.Instance('pbcroot', ootype.ROOT) class MultipleFrozenPBCRepr(AbstractMultipleFrozenPBCRepr): """Representation selected for multiple non-callable pre-built constants.""" def __init__(self, rtyper, access_set): self.rtyper = rtyper self.access_set = access_set self.lowleveltype = ootype.Instance('pbc', PBCROOT, _hints={'immutable': True}) self.pbc_cache = {} def _setup_repr(self): fields_list = self._setup_repr_fields() ootype.addFields(self.lowleveltype, dict(fields_list)) def create_instance(self): return ootype.new(self.lowleveltype)
def setup_specfunc(self): fields = {} for row in self.uniquerows: fields[row.attrname] = row.fntype return ootype.Instance('specfunc', ootype.ROOT, fields)