def test_any_as_argument():
@signature(types.any(), types.int(), returns=types.float())
def f(x, y):
return x + y
@signature(types.int(), returns=types.float())
def g(x):
return f(x, x)
sig = getsig(g)
assert sig == [model.SomeInteger(), model.SomeFloat()]
@signature(types.float(), returns=types.float())
def g(x):
return f(x, 4)
sig = getsig(g)
assert sig == [model.SomeFloat(), model.SomeFloat()]
@signature(types.str(), returns=types.int())
def cannot_add_string(x):
return f(x, 2)
exc = py.test.raises(model.AnnotatorError, annotate_at,
cannot_add_string).value
assert 'Blocked block' in str(exc)
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) == 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
def test_float():
@signature(types.longfloat(), types.singlefloat(), returns=types.float())
def f(a, b):
return 3.0
assert getsig(f) == [
model.SomeLongFloat(),
model.SomeSingleFloat(),
model.SomeFloat()
]
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(x, 'g', 17)
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 rstring_to_float(s)
add_loader(annmodel.SomeFloat(), load_float)
def dump_string_or_none(buf, x):
if x is None:
def test_reprkeys_dont_clash():
stup1 = annmodel.SomeTuple((annmodel.SomeFloat(), annmodel.SomeInteger()))
stup2 = annmodel.SomeTuple((annmodel.SomeString(), annmodel.SomeInteger()))
key1 = stup1.rtyper_makekey()
key2 = stup2.rtyper_makekey()
assert key1 != key2
def compute_result_annotation(self, str_s):
assert isinstance(str_s, annmodel.SomeOOInstance)\
and str_s.ootype is ootype.String
return annmodel.SomeFloat()
