def __init__(self, r_list):
self.r_list = r_list
self.lowleveltype = ootype.Record(
{"iterable": r_list.lowleveltype, "index": ootype.Signed})
self.ll_listiter = ll_listiter
self.ll_listnext = ll_listnext
self.ll_getnextindex = ll_getnextindex
def TUPLE_TYPE(field_lltypes):
if len(field_lltypes) == 0:
return ootype.Void # empty tuple
else:
fields = [('item%d' % i, TYPE) for i, TYPE in enumerate(field_lltypes)]
hints = {'immutable': True, 'noidentity': True}
return ootype.Record(fields, _hints=hints)
class UnicodeIteratorRepr(AbstractStringIteratorRepr):
lowleveltype = ootype.Record({'string': unicode_repr.lowleveltype,
'index': ootype.Signed})
def __init__(self):
self.ll_striter = ll_unicodeiter
self.ll_strnext = ll_strnext
def _make_empty_type(self):
if self.known_maxlength:
return ootype.Record({
"items": ootype.Array(),
"length": ootype.Signed
})
else:
return ootype.List()
def __init__(self, r_tuple):
self.r_tuple = r_tuple
self.lowleveltype = ootype.Record({
"iterable": r_tuple.lowleveltype,
"index": ootype.Signed
})
self.ll_tupleiter = ll_tupleiter
self.ll_tuplenext = ll_tuplenext
def test_box_unbox_oorecord(self):
A = ootype.Record({'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_cast_record_pbc(self):
T = ootype.Record({'x': ootype.Signed})
record = ootype.new(T)
record.x = 42
obj = cast_record_to_object(record)
def fn():
record2 = cast_object_to_record(T, obj)
return record is record2
res = self.interpret(fn, [])
assert res
def test_cast_object_record(self):
B = ootype.Record({'x': ootype.Signed})
def fn_record():
b = ootype.new(B)
b.x = 42
obj = ootype.cast_to_object(b)
b2 = ootype.cast_from_object(B, obj)
assert b2.x == 42
assert b is b2
self.interpret(fn_record, [])
def test_cast_record(self):
T = ootype.Record({'x': ootype.Signed})
record = ootype.new(T)
def fn(flag):
if flag:
obj = cast_record_to_object(record)
else:
obj = System.Object()
record2 = cast_object_to_record(T, obj)
return record is record2
res = self.interpret(fn, [True])
assert res
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 setup_excdata(self):
EXCDATA = ootype.Record({
'exc_type': self.lltype_of_exception_type,
'exc_value': self.lltype_of_exception_value
})
self.EXCDATA = EXCDATA
exc_data = ootype.new(EXCDATA)
null_type = ootype.null(self.lltype_of_exception_type)
null_value = ootype.null(self.lltype_of_exception_value)
self.exc_data_ptr = exc_data
self.cexcdata = Constant(exc_data, self.EXCDATA)
self.c_null_etype = Constant(null_type, self.lltype_of_exception_type)
self.c_null_evalue = Constant(null_value,
self.lltype_of_exception_value)
return exc_data, null_type, null_value
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.translator.cli.support import string_literal, Counter
from pypy.translator.cli.cts import types
from pypy.rpython.ootypesystem import ootype
from pypy.rpython.ootypesystem.module import ll_os
from pypy.translator.cli import dotnet
from pypy.rlib.objectmodel import CDefinedIntSymbolic
from pypy.translator.oosupport.database import Database as OODatabase
try:
set
except NameError:
from sets import Set as set
BUILTIN_RECORDS = {
ootype.Record({
"item0": ootype.Signed,
"item1": ootype.Signed
}): '[pypylib]pypy.runtime.Record_Signed_Signed',
ootype.Record({
"item0": ootype.Float,
"item1": ootype.Signed
}): '[pypylib]pypy.runtime.Record_Float_Signed',
ootype.Record({
"item0": ootype.Float,
"item1": ootype.Float
}): '[pypylib]pypy.runtime.Record_Float_Float',
ootype.Record({
"item0": ootype.String,
"item1": ootype.String
}): '[pypylib]pypy.runtime.Record_String_String',
ll_os.STAT_RESULT: '[pypylib]pypy.runtime.Record_Stat_Result',
}
def __init__(self, rtyper, items_r):
AbstractTupleRepr.__init__(self, rtyper, items_r)
self.lowleveltype = ootype.Record(
dict(zip(self.fieldnames, self.lltypes)))
def TUPLE_TYPE(field_lltypes):
if len(field_lltypes) == 0:
return Void # empty tuple
else:
fields = [('item%d' % i, TYPE) for i, TYPE in enumerate(field_lltypes)]
return ootype.Record(dict(fields))
def _get_type(self):
KEYTYPE = self.r_dict.key_repr.lowleveltype
VALUETYPE = self.r_dict.value_repr.lowleveltype
ITER = ootype.DictItemsIterator(KEYTYPE, VALUETYPE)
return ootype.Record({"iterator": ITER})
def test_cast_record_mix_object(self):
T = ootype.Record({'x': ootype.Signed})
NULL = ootype.null(System.Object._INSTANCE)
record = cast_record_to_object(ootype.new(T))
assert record != NULL
assert NULL != record
import math
from pypy.rpython.ootypesystem import ootype
FREXP_RESULT = ootype.Record({"item0": ootype.Float, "item1": ootype.Signed})
MODF_RESULT = ootype.Record({"item0": ootype.Float, "item1": ootype.Float})
def ll_frexp_result(mantissa, exponent):
tup = ootype.new(FREXP_RESULT)
tup.item0 = mantissa
tup.item1 = exponent
return tup
def ll_modf_result(fracpart, intpart):
tup = ootype.new(MODF_RESULT)
tup.item0 = fracpart
tup.item1 = intpart
return tup
def ll_math_frexp(x):
mantissa, exponent = math.frexp(x)
return ll_frexp_result(mantissa, exponent)
def ll_math_modf(x):
fracpart, intpart = math.modf(x)
return ll_modf_result(fracpart, intpart)
def _make_tuple(FIELDS):
n = len(FIELDS)
fieldnames = ['item%d' % i for i in range(n)]
fields = dict(zip(fieldnames, FIELDS))
return ootype.Record(fields)
