def make_simple_table(cls, keys=None, vals=None, immutable=False):
data = r_dict(cls.cmp_value, cls.hash_value, force_non_null=True)
if keys is not None and vals is not None:
assert len(keys) == len(vals)
for i, k in enumerate(keys):
data[k] = vals[i]
return cls(data, immutable)
def sub(self,right):
result = r_dict(dict_eq, dict_hash)
for key, val in self.values.iteritems():
result[key] = val
del result[right]
return Dict(result)
def func(i):
d = r_dict(eq, rhash, force_non_null=True)
if not i:
d[None] = i
else:
d[str(i)] = i
return "12" in d, d
def get_key_to_index(self):
from pypy.objspace.std.dictmultiobject import unicode_hash, unicode_eq
key_to_index = self.key_to_index
if key_to_index is None:
key_to_index = self.key_to_index = objectmodel.r_dict(
unicode_eq,
unicode_hash,
force_non_null=True,
simple_hash_eq=True)
# compute depth
curr = self
depth = 0
while True:
depth += 1
curr = curr.prev
if not isinstance(curr, JSONMap):
break
curr = self
while depth:
depth -= 1
key_to_index[curr.w_key] = depth
curr = curr.prev
if not isinstance(curr, JSONMap):
break
return key_to_index
def test_rtype_constant_r_dicts(self):
d1 = r_dict(strange_key_eq, strange_key_hash)
d1['hello'] = 666
d2 = r_dict(strange_key_eq, strange_key_hash)
d2['hello'] = 777
d2['world'] = 888
def fn(i):
if i == 1:
d = d1
else:
d = d2
return len(d)
res = self.interpret(fn, [1])
assert res == 1
res = self.interpret(fn, [2])
assert res == 2
def func(i):
d = r_dict(eq, rhash, force_non_null=True)
if not i:
d[None] = i
else:
d[str(i)] = i
return "12" in d, d
def sub(self, right):
result = r_dict(dict_eq, dict_hash)
for key, val in self.values.iteritems():
result[key] = val
del result[right]
return Dict(result)
def make_simple_mutable_table(cls, keys=None, vals=None):
data = r_dict(cls.cmp_value, cls.hash_value, force_non_null=True)
if keys is not None and vals is not None:
assert len(keys) == len(vals)
for i, k in enumerate(keys):
data[k] = vals[i]
return cls(data)
def f(n):
dct = objectmodel.r_dict(eq, key)
total = n
while total:
myjitdriver.jit_merge_point(total=total, dct=dct)
dct[total] = dct.get(total, 0) + 1
total -= 1
return dct[0]
def f():
d1 = r_dict(eq, raising_hash)
d1['xxx'] = 1
try:
x = d1["blabla"]
except Exception:
return 42
return x
def intersection(self, other):
new_map = r_dict(my_eq, my_hash)
for e in other.hashmap:
if e in self.hashmap:
new_map[e] = True
result = frozenset()
result.hashmap = new_map
return result
def test_r_dict_move_to_end():
d = r_dict(strange_key_eq, strange_key_hash)
d['1key'] = 'val1'
d['2key'] = 'val2'
d['3key'] = 'val3'
# does not crash, we can't check that it actually moves to end on CPython
move_to_end(d, '1key')
move_to_end(d, '1key', last=False)
def f():
d1 = r_dict(eq, raising_hash)
d1['xxx'] = 1
try:
x = d1["blabla"]
except Exception:
return 42
return x
def f():
d1 = r_dict(eq, raising_hash)
d1['xxx'] = 1
try:
d1["blabla"] = 2
except TypeError:
return 42
return 0
def f():
d1 = r_dict(eq, raising_hash)
d1['xxx'] = 1
try:
d1["blabla"] = 2
except TypeError:
return 42
return 0
def f(n):
dct = objectmodel.r_dict(eq, key)
total = n
while total:
myjitdriver.jit_merge_point(total=total, dct=dct)
dct[total] = dct.get(total, 0) + 1
total -= 1
return dct[0]
def __init__(self, space):
self.ctvoid = None # There can be only one
self.ctvoidp = None # Cache for self.pointers[self.ctvoid]
self.ctchara = None # Cache for self.arrays[charp, -1]
self.primitives = {} # Keys: name
self.pointers = {} # Keys: base_ctype
self.arrays = {} # Keys: (ptr_ctype, length_or_-1)
self.functions = r_dict(# Keys: (fargs, w_fresult, ellipsis)
_func_key_eq, _func_key_hash)
def test_rtype_constant_r_dicts(self):
d1 = r_dict(strange_key_eq, strange_key_hash)
d1['hello'] = 666
d2 = r_dict(strange_key_eq, strange_key_hash)
d2['hello'] = 777
d2['world'] = 888
def fn(i):
if i == 1:
d = d1
else:
d = d2
return len(d)
res = self.interpret(fn, [1])
assert res == 1
res = self.interpret(fn, [2])
assert res == 2
def __init__(self, space):
self.ctvoid = None # There can be only one
self.ctvoidp = None # Cache for self.pointers[self.ctvoid]
self.ctchara = None # Cache for self.arrays[charp, -1]
self.primitives = {} # Keys: name
self.pointers = {} # Keys: base_ctype
self.arrays = {} # Keys: (ptr_ctype, length_or_-1)
self.functions = r_dict( # Keys: (fargs, w_fresult, ellipsis)
_func_key_eq, _func_key_hash)
def __init__(self, arity, default=null, doc=null):
self.arity = arity
self.multimethod_table = r_dict(eq_fn, hash_fn, force_non_null=True)
self.version = VersionTag(
) # The version tag is required because the result 'None'
# from the get_impl/get_method can be very useful due
# to the .default -function call behavior.
self.default = default
self.doc = doc
def f(n):
d = None
while n > 0:
myjitdriver.jit_merge_point(n=n, d=d)
d = objectmodel.r_dict(eq_func, hash_func)
y = Wrapper(str(n))
d[y] = n - 1
n = d[y]
return d[Wrapper(str(n + 1))]
def f(n):
d = None
while n > 0:
myjitdriver.jit_merge_point(n=n, d=d)
d = objectmodel.r_dict(eq_func, hash_func)
y = Wrapper(str(n))
d[y] = n - 1
n = d[y]
return d[Wrapper(str(n + 1))]
def test_rtype_r_dict_singlefrozen_func_pbc(self):
class FreezingClass(Strange):
def _freeze_(self):
return True
obj = FreezingClass()
pbc_d = r_dict(obj.key_eq, obj.key_hash)
def fn():
return play_with_r_dict(pbc_d)
assert self.interpret(fn, []) is True
def f(n):
dct = objectmodel.r_dict(eq, key)
total = n
while total:
myjitdriver.jit_merge_point(total=total, dct=dct)
if total not in dct:
dct[total] = []
dct[total].append(total)
total -= 1
return len(dct[0])
def f(n):
dct = objectmodel.r_dict(eq, key)
total = n
while total:
myjitdriver.jit_merge_point(total=total, dct=dct)
if total not in dct:
dct[total] = []
dct[total].append(total)
total -= 1
return len(dct[0])
def __init__(self, kvs=[], w_meta=w_nil):
assert len(kvs) % 2 == 0
W_Obj.__init__(self, w_meta)
self.dict = r_dict(
lambda this, other: this.equals(other),
lambda obj: obj.hash()
)
idx = 0
while idx < len(kvs):
self.dict[kvs[idx]] = kvs[idx + 1]
idx += 2
def __init__(self, space, s):
self.space = space
self.s = s
# we put our string in a raw buffer so:
# 1) we automatically get the '\0' sentinel at the end of the string,
# which means that we never have to check for the "end of string"
# 2) we can pass the buffer directly to strtod
self.ll_chars = rffi.str2charp(s)
self.end_ptr = lltype.malloc(rffi.CCHARPP.TO, 1, flavor='raw')
self.pos = 0
self.cache = r_dict(slice_eq, slice_hash, simple_hash_eq=True)
def _gcref_index(self, gcref):
if self.gcrefs_map is None:
self.gcrefs_map = r_dict(rd_eq, rd_hash)
try:
return self.gcrefs_map[gcref]
except KeyError:
pass
index = len(self.gcrefs_output_list)
self.gcrefs_map[gcref] = index
self.gcrefs_output_list.append(gcref)
return index
def _gcref_index(self, gcref):
if self.gcrefs_map is None:
self.gcrefs_map = r_dict(rd_eq, rd_hash)
try:
return self.gcrefs_map[gcref]
except KeyError:
pass
index = len(self.gcrefs_output_list)
self.gcrefs_map[gcref] = index
self.gcrefs_output_list.append(gcref)
return index
def add(self, right):
if isinstance(right, Dict):
result = Dict(r_dict(dict_eq, dict_hash))
for key, val in self.values.iteritems():
result.values[key] = val
for key, val in right.values.iteritems():
result.values[key] = val
return result
raise LogicError("Cannot add that to dict")
def add(self, right):
if isinstance(right, Dict):
result = Dict(r_dict(dict_eq, dict_hash))
for key, val in self.values.iteritems():
result.values[key] = val
for key, val in right.values.iteritems():
result.values[key] = val
return result
raise LogicError("Cannot add that to dict")
def make_simple_mutable_table_assocs(cls, assocs, who):
if not assocs.is_proper_list():
raise SchemeException("%s: not given proper list" % who)
data = r_dict(cls.cmp_value, cls.hash_value, force_non_null=True)
while isinstance(assocs, values.W_Cons):
entry, assocs = assocs.car(), assocs.cdr()
if not isinstance(entry, values.W_Cons):
raise SchemeException("%s: expected list of pairs" % who)
key, val = entry.car(), entry.cdr()
data[key] = val
return cls(data)
def test_rtype_r_dict_singlefrozen_func_pbc(self):
class FreezingClass(Strange):
def _freeze_(self):
return True
obj = FreezingClass()
pbc_d = r_dict(obj.key_eq, obj.key_hash)
def fn():
return play_with_r_dict(pbc_d)
assert self.interpret(fn, []) is True
def __init__(self, state, next_varno):
self.sofar = []
self.state = state
self.next_varno = next_varno
self.backtrack = 0
self.next_chrid = 0
self.chr_by_id = {}
self.chr_by_fsym = {}
self.chr_history_set = r_dict(hist_eq, hist_hash, force_non_null=True)
self.chr_occur = {}
self.chr_debug = False
self.chr_lock = False
def Set_intersection_update(self, argv):
for arg in argv:
it = arg.iter()
common = r_dict(eq_fn, hash_fn, force_non_null=True)
try:
while True:
item = it.callattr(u"next", [])
if item in self._set:
common[item] = None
except StopIteration as stop:
pass
self._set = common
return null
def f(i):
d = r_dict(strange_key_eq, strange_key_hash)
h = strange_key_hash("abc")
assert h == strange_key_hash("aXX") and strange_key_eq("abc", "aXX")
setitem_with_hash(d, "abc", h, i)
assert getitem_with_hash(d, "aXX", h) == i
try:
getitem_with_hash(d, "bYY", strange_key_hash("bYY"))
except KeyError:
pass
else:
raise AssertionError
return 0
def f(i):
d = r_dict(strange_key_eq, strange_key_hash)
h = strange_key_hash("abc")
assert h == strange_key_hash("aXX") and strange_key_eq("abc", "aXX")
setitem_with_hash(d, "abc", h, i)
assert getitem_with_hash(d, "aXX", h) == i
try:
getitem_with_hash(d, "bYY", strange_key_hash("bYY"))
except KeyError:
pass
else:
raise AssertionError
return 0
def Set_intersection_update(self, argv):
for arg in argv:
it = arg.iter()
common = r_dict(eq_fn, hash_fn, force_non_null=True)
try:
while True:
item = it.callattr(u"next", [])
if item in self._set:
common[item] = None
except StopIteration as stop:
pass
self._set = common
return null
def __init__(self, L=None):
W_Object.__init__(self)
if L is None:
L = []
self.hashmap = r_dict(my_eq, my_hash)
# frozenset([1,1,2])==frozenset([1,2])
# TODO: maybe the performance improves if cases like frozenset([1,1,2])
# are not used by any pyB code. (only enumerated sets and the repl. needs this check then)
assert isinstance(L, list)
for e in L:
self.hashmap[e] = True
self.repr_string = None
self.hash_computed = False
self.my_hash = 0
def f(n):
dct = objectmodel.r_dict(eq, key)
total = n
x = 44444
y = 55555
z = 66666
while total:
myjitdriver.jit_merge_point(total=total, dct=dct)
dct[total] = total
x = dct[total]
y = dct[total]
z = dct[total]
total -= 1
return len(dct) + x + y + z
def f(n):
dct = objectmodel.r_dict(eq, key)
total = n
x = 44444
y = 55555
z = 66666
while total:
myjitdriver.jit_merge_point(total=total, dct=dct)
dct[total] = total
x = dct[total]
y = dct[total]
z = dct[total]
total -= 1
return len(dct) + x + y + z
def func():
d = r_dict(deq, dhash)
d[5] = 2
d[6] = 3
k1, v1 = d.popitem()
assert len(d) == 1
k2, v2 = d.popitem()
try:
d.popitem()
except KeyError:
pass
else:
assert 0, "should have raised KeyError"
assert len(d) == 0
return k1*1000 + v1*100 + k2*10 + v2
def get_next(self, w_key, string, start, stop, terminator):
""" Returns the next map, given a wrapped key w_key, the json input
string with positions start and stop, as well as a terminator.
Returns None if the key already appears somewhere in the map chain.
"""
from pypy.objspace.std.dictmultiobject import unicode_hash, unicode_eq
if isinstance(self, JSONMap):
assert not self.state == MapBase.BLOCKED
nextmap_first = self.nextmap_first
if (nextmap_first is not None and nextmap_first.w_key.eq_w(w_key)):
return nextmap_first
assert stop >= 0
assert start >= 0
if nextmap_first is None:
# first transition ever seen, don't initialize nextmap_all
next = self._make_next_map(w_key, string[start:stop])
if next is None:
return None
self.nextmap_first = next
else:
if self.nextmap_all is None:
# 2nd transition ever seen
self.nextmap_all = objectmodel.r_dict(unicode_eq,
unicode_hash,
force_non_null=True,
simple_hash_eq=True)
self.nextmap_all[nextmap_first.w_key] = nextmap_first
else:
next = self.nextmap_all.get(w_key, None)
if next is not None:
return next
# if we are at this point we didn't find the transition yet, so
# create a new one
next = self._make_next_map(w_key, string[start:stop])
if next is None:
return None
self.nextmap_all[w_key] = next
# one new leaf has been created
self.change_number_of_leaves(1)
terminator.register_potential_fringe(next)
return next
def test_customdict_circular(self):
from rpython.rlib.objectmodel import r_dict
def key_eq(a, b):
return a.x[0] == b.x[0]
def key_hash(a):
return ord(a.x[0])
class A:
def __init__(self, x):
self.x = x
a = A('foo')
a.dict = r_dict(key_eq, key_hash)
a.dict[a] = 42
def fn(b):
if b:
s = A('foo')
else:
s = A('bar')
return a.dict[s]
assert self.interpret(fn, [True]) == 42
def test_constant_r_dict(self):
def strange_key_eq(key1, key2):
return key1[0] == key2[0] # only the 1st character is relevant
def strange_key_hash(key):
return ord(key[0])
d = r_dict(strange_key_eq, strange_key_hash)
d['hello'] = 42
d['world'] = 43
for x in range(65, 91):
d[chr(x)] = x * x
def func(i):
return d[chr(i)]
res = self.interpret(func, [ord('h')])
assert res == 42
res = self.interpret(func, [ord('w')])
assert res == 43
for x in range(65, 91):
res = self.interpret(func, [x])
assert res == x * x
def f(n):
d = r_dict(myeq, myhash)
for i in range(10):
d[i] = i*i
try:
value1 = d[n]
except FooError:
value1 = 99
try:
value2 = n in d
except FooError:
value2 = 99
try:
value3 = d[-n]
except FooError:
value3 = 99
try:
value4 = (-n) in d
except FooError:
value4 = 99
return (value1 * 1000000 +
value2 * 10000 +
value3 * 100 +
value4)
def func_r_dict_bm():
# NB. this test function is also annotated by the next tests
strange = Strange()
d = r_dict(strange.key_eq, strange.key_hash)
return play_with_r_dict(d)
def func_r_dict():
# NB. this test function is also annotated/rtyped by the next tests
d = r_dict(strange_key_eq, strange_key_hash)
return play_with_r_dict(d)
def test_recursive_r_dict_repr():
import operator
rdic = r_dict(operator.eq, hash)
rdic['x'] = rdic
assert str(rdic) == "r_dict({'x': r_dict({...})})"
assert repr(rdic) == "r_dict({'x': r_dict({...})})"
def g(n):
d = r_dict(eq, h)
d[1] = n
f(d)
return d[2]
def g(n):
d = r_dict(eq, h)
d[1] = n
d[2] = 2 * n
return f(d)
def fn():
d = r_dict(obj.key_eq, obj.key_hash)
return play_with_r_dict(d)
def __init__(self):
self.data = r_dict(eq_fn, hash_fn, force_non_null=True)
def new_ref_dict_3(self):
return r_dict(rd_eq, rd_hash)
def _create_empty_dict(self):
return r_dict(cmp_immutable_bytes, hash_immutable_bytes)
def _create_empty_dict(self):
return r_dict(cmp_strings, hash_strings)
def _create_empty_dict(self):
return r_dict(cmp_bytes, hash_bytes)
