class DTestFuncEntry(ExtFuncEntry):
_about_ = d
name = 'd'
signature_args = [
annmodel.SomeGenericCallable(args=[], result=annmodel.SomeFloat())
]
signature_result = annmodel.SomeFloat()
def test_reprkeys_dont_clash():
stup1 = annmodel.SomeTuple((annmodel.SomeFloat(), annmodel.SomeInteger()))
stup2 = annmodel.SomeTuple((annmodel.SomeString(), annmodel.SomeInteger()))
rtyper = RPythonTyper(annrpython.RPythonAnnotator(None))
key1 = rtyper.makekey(stup1)
key2 = rtyper.makekey(stup2)
assert key1 != key2
def test_some_generic_function_call(self):
def h(x):
return int(x)
def c(x):
return int(x) + 1
def default(x):
return int(x) + 3
def g(a, x):
if x == -1:
a = None
if x > 0:
if x == 1:
a = h
else:
a = c
x = x + 0.01
return a(x)
def f(x):
return g(default, x)
g._annenforceargs_ = policy.Sig(
annmodel.SomeGenericCallable(args=[annmodel.SomeFloat()],
result=annmodel.SomeInteger()), float)
assert interpret(f, [1.]) == 1
assert interpret(f, [10.]) == 11
assert interpret(f, [-3.]) == 0
class CC(BasicExternal):
_methods = {
'some_method':
MethodDesc([
annmodel.SomeGenericCallable(args=[annmodel.SomeInteger()],
result=annmodel.SomeFloat())
], int)
}
def test_ll_calling_ll(self):
A = GcArray(Float)
B = GcArray(Signed)
def ll_make(T, n):
x = malloc(T, n)
return x
def ll_get(T, x, i):
return x[i]
def llf():
a = ll_make(A, 3)
b = ll_make(B, 2)
a[0] = 1.0
b[1] = 3
y0 = ll_get(A, a, 1)
y1 = ll_get(B, b, 1)
#
a2 = ll_make(A, 4)
a2[0] = 2.0
return ll_get(A, a2, 1)
s = self.annotate(llf, [])
a = self.a
assert s == annmodel.SomeFloat()
seen = {}
ngraphs = len(a.translator.graphs)
vTs = []
for call in annotated_calls(a):
if derived(call, "ll_"):
func, T = [x.value for x in call.args[0:2]]
if (func, T) in seen:
continue
seen[func, T] = True
desc = a.bookkeeper.getdesc(func)
g = desc.specialize([a.binding(x) for x in call.args[1:]])
args = g.getargs()
rv = g.getreturnvar()
if func is ll_get:
vT, vp, vi = args
assert a.binding(vT) == a.bookkeeper.immutablevalue(T)
assert a.binding(vi).knowntype == int
assert a.binding(vp).ll_ptrtype.TO == T
assert a.binding(rv) == annmodel.lltype_to_annotation(T.OF)
elif func is ll_make:
vT, vn = args
assert a.binding(vT) == a.bookkeeper.immutablevalue(T)
assert a.binding(vn).knowntype == int
assert a.binding(rv).ll_ptrtype.TO == T
else:
assert False, func
vTs.append(vT)
assert len(seen) == 4
return a, vTs # reused by a test in test_rtyper
x = r_longlong(readlong(loader)) & r_32bits_mask
x |= (r_longlong(readlong(loader)) << 32)
return x
add_loader(annotation(r_longlong), load_longlong)
def dump_float(buf, x):
buf.append(TYPE_FLOAT)
s = formatd("%.17g", x)
buf.append(chr(len(s)))
buf += s
add_dumper(annmodel.SomeFloat(), dump_float)
def load_float(loader):
if readchr(loader) != TYPE_FLOAT:
raise ValueError("expected a float")
length = ord(readchr(loader))
s = readstr(loader, length)
return parts_to_float(*break_up_float(s))
add_loader(annmodel.SomeFloat(), load_float)
def dump_string_or_none(buf, x):
if x is None:
def test_ll_calling_ll2(self):
A = GcArray(Float)
B = GcArray(Signed)
def ll_make(T, n):
x = malloc(T, n)
return x
def ll_get(x, i):
return x[i]
def makelen4(T):
return ll_make(T, 4)
def llf():
a = ll_make(A, 3)
b = ll_make(B, 2)
a[0] = 1.0
b[1] = 3
y0 = ll_get(a, 1)
y1 = ll_get(b, 1)
#
a2 = makelen4(A)
a2[0] = 2.0
return ll_get(a2, 1)
s = self.annotate(llf, [])
a = self.a
assert s == annmodel.SomeFloat()
seen = {}
def q(v):
s = a.binding(v)
if s.is_constant():
return s.const
else:
return s.ll_ptrtype
vTs = []
for call in annotated_calls(a):
if derived(call, "ll_") or derived(call, "makelen4"):
func, T = [q(x) for x in call.args[0:2]]
if (func, T) in seen:
continue
seen[func, T] = True
desc = a.bookkeeper.getdesc(func)
g = desc.specialize([a.binding(x) for x in call.args[1:]])
args = g.getargs()
rv = g.getreturnvar()
if func is ll_make:
vT, vn = args
assert a.binding(vT) == a.bookkeeper.immutablevalue(T)
assert a.binding(vn).knowntype == int
assert a.binding(rv).ll_ptrtype.TO == T
vTs.append(vT)
elif func is makelen4:
vT, = args
assert a.binding(vT) == a.bookkeeper.immutablevalue(T)
assert a.binding(rv).ll_ptrtype.TO == T
vTs.append(vT)
elif func is ll_get:
vp, vi = args
assert a.binding(vi).knowntype == int
assert a.binding(vp).ll_ptrtype == T
assert a.binding(rv) == annmodel.lltype_to_annotation(
T.TO.OF)
else:
assert False, func
assert len(seen) == 5
return a, vTs # reused by a test in test_rtyper
def compute_result_annotation(self, str_s):
assert isinstance(str_s, annmodel.SomeOOInstance)\
and str_s.ootype is ootype.String
return annmodel.SomeFloat()
class CD(BasicExternal):
_fields = {
'callback_field':
annmodel.SomeGenericCallable([annmodel.SomeInteger()],
annmodel.SomeFloat())
}
def compute_result_annotation(self, s_float):
assert annmodel.SomeFloat().contains(s_float)
return annmodel.SomeInteger(knowntype=r_int64)
