def find(self, shift, hash_val, key, not_found):
for x in range(0, len(self._array), 2):
key_or_nil = self._array[x]
if key_or_nil is not None and rt.eq(key_or_nil, key):
return self._array[x + 1]
return not_found
def find(self, shift, hash_val, key, not_found):
for x in range(0, len(self._array), 2):
key_or_nil = self._array[x]
if key_or_nil is not None and rt.eq(key_or_nil, key):
return self._array[x + 1]
return not_found
def without_inode(self, shift, hash, key):
bit = bitpos(hash, shift)
if self._bitmap & bit == 0:
return self
idx = self.index(bit)
key_or_none = self._array[2 * idx]
val_or_node = self._array[2 * idx + 1]
if key_or_none is None:
n = val_or_node.without_inode(shift + 5, hash, key)
if n is val_or_node:
return self
if n is not None:
return BitmapIndexedNode(None, self._bitmap, clone_and_set(self._array, 2 * idx + 1, n))
if self._bitmap == bit:
return None
return BitmapIndexedNode(None, self._bitmap ^ bit, remove_pair(self._array, idx))
if rt.eq(key, key_or_none):
return BitmapIndexedNode(None, self._bitmap ^ bit, remove_pair(self._array, idx))
return self
def without_inode(self, shift, hash, key):
bit = bitpos(hash, shift)
if self._bitmap & bit == 0:
return self
idx = self.index(bit)
key_or_none = self._array[2 * idx]
val_or_node = self._array[2 * idx + 1]
if key_or_none is None:
n = val_or_node.without_inode(shift + 5, hash, key)
if n is val_or_node:
return self
if n is not None:
return BitmapIndexedNode(
None, self._bitmap,
clone_and_set(self._array, 2 * idx + 1, n))
if self._bitmap == bit:
return None
return BitmapIndexedNode(None, self._bitmap ^ bit,
remove_pair(self._array, idx))
if rt.eq(key, key_or_none):
return BitmapIndexedNode(None, self._bitmap ^ bit,
remove_pair(self._array, idx))
return self
def find_index(self, key):
i = r_int(0)
while i < len(self._array):
if rt.eq(key, self._array[i]):
return i
i += 2
return r_int(-1)
def find_index(self, key):
i = 0
while i < len(self._array):
if rt.eq(key, self._array[i]):
return i
i += 2
return -1
def find_index(self, key):
i = r_int(0)
while i < len(self._array):
if rt.eq(key, self._array[i]):
return i
i += 2
return r_int(-1)
def _eq(self, obj):
if self is obj:
return true
elif isinstance(obj, PersistentVector):
if self._cnt != obj._cnt:
return false
for i in range(0, intmask(self._cnt)):
if not rt.eq(self.nth(i), obj.nth(i)):
return false
return true
else:
if not rt.satisfies_QMARK_(proto.ISeqable, obj):
return false
seq = rt.seq(obj)
for i in range(0, intmask(self._cnt)):
if seq is nil or not rt.eq(self.nth(i), rt.first(seq)):
return false
seq = rt.next(seq)
if seq is not nil:
return false
return true
def find(self, shift, hash_val, key, not_found):
bit = bitpos(hash_val, shift)
if (self._bitmap & bit) == 0:
return not_found
idx = self.index(bit)
key_or_null = self._array[2 * idx]
val_or_node = self._array[2 * idx + 1]
if key_or_null is None:
return val_or_node.find(shift + 5, hash_val, key, not_found)
if rt.eq(key, key_or_null):
return val_or_node
return not_found
def find(self, shift, hash_val, key, not_found):
bit = bitpos(hash_val, shift)
if (self._bitmap & bit) == 0:
return not_found
idx = self.index(bit)
key_or_null = self._array[2 * idx]
val_or_node = self._array[2 * idx + 1]
if key_or_null is None:
return val_or_node.find(shift + 5, hash_val, key, not_found)
if rt.eq(key, key_or_null):
return val_or_node
return not_found
def assoc_inode(self, shift, hash_val, key, val, added_leaf):
bit = bitpos(hash_val, shift)
idx = self.index(bit)
if (self._bitmap & bit) != 0:
key_or_null = self._array[2 * idx]
val_or_node = self._array[2 * idx + 1]
if key_or_null is None:
assert isinstance(val_or_node, INode)
n = val_or_node.assoc_inode(shift + 5, hash_val, key, val, added_leaf)
if n is val_or_node:
return self
return BitmapIndexedNode(None, self._bitmap, clone_and_set(self._array, 2 * idx + 1, n))
if key_or_null is None or rt.eq(key, key_or_null):
if val is val_or_node:
return self
return BitmapIndexedNode(None, self._bitmap, clone_and_set(self._array, 2 * idx + 1, val))
added_leaf._val = added_leaf
return BitmapIndexedNode(None, self._bitmap,
clone_and_set2(self._array,
2 * idx, None,
2 * idx + 1, create_node(shift+ 5, key_or_null, val_or_node, hash_val, key, val)))
else:
n = bit_count(self._bitmap)
if n >= 16:
nodes = [None] * 32
jdx = mask(hash_val, shift)
nodes[jdx] = BitmapIndexedNode_EMPTY.assoc_inode(shift + 5, hash_val, key, val, added_leaf)
j = 0
for i in range(32):
if (self._bitmap >> i) & 1 != 0:
if self._array[j] is None:
nodes[i] = self._array[j + 1]
else:
nodes[i] = BitmapIndexedNode_EMPTY.assoc_inode(shift + 5, rt.hash(self._array[j]),
self._array[j], self._array[j + 1], added_leaf)
j += 1
return ArrayNode(None, n + 1, nodes)
else:
new_array = [None] * (2 * (n + 1))
list_copy(self._array, 0, new_array, 0, 2 * idx)
new_array[2 * idx] = key
added_leaf._val = added_leaf
new_array[2 * idx + 1] = val
list_copy(self._array, 2 * idx, new_array, 2 * (idx + 1), 2 * (n - idx))
return BitmapIndexedNode(None, self._bitmap | bit, new_array)
def _eq(self, obj):
assert isinstance(self, PersistentVector)
if self is obj:
return true
elif isinstance(obj, PersistentVector):
if self._cnt != obj._cnt:
return false
for i in range(0, intmask(self._cnt)):
if not rt.eq(self.nth(i), obj.nth(i)):
return false
return true
else:
if obj is nil or not rt.satisfies_QMARK_(proto.ISeqable, obj):
return false
seq = rt.seq(obj)
for i in range(0, intmask(self._cnt)):
if seq is nil or not rt.eq(self.nth(i), rt.first(seq)):
return false
seq = rt.next(seq)
if seq is not nil:
return false
return true
def invoke(self, rdr, ch):
if ARG_ENV.deref() is nil:
return read_symbol(rdr, ch)
ch = rdr.read()
rdr.unread()
if is_whitespace(ch) or is_terminating_macro(ch):
return ArgReader.register_next_arg(1)
n = read_inner(rdr, True)
if rt.eq(n, ARG_AMP):
return ArgReader.register_next_arg(-1)
if not isinstance(n, numbers.Integer):
throw_syntax_error_with_data(rdr, u"%-arg must be %, %<integer> or %&")
return ArgReader.register_next_arg(n.int_val())
def is_unquote_splicing(form):
return True if rt.satisfies_QMARK_(rt.ISeq.deref(), form) \
and rt.eq(rt.first(form), UNQUOTE_SPLICING) \
else False
def is_unquote(form):
return True if rt.satisfies_QMARK_(rt.ISeq.deref(), form) \
and rt.eq(rt.first(form), UNQUOTE) \
else False
def is_unquote_splicing(form):
return True if rt._satisfies_QMARK_(rt.ISeq.deref(), form) \
and rt.eq(rt.first(form), UNQUOTE_SPLICING) \
else False
def is_unquote(form):
return True if rt._satisfies_QMARK_(rt.ISeq.deref(), form) \
and rt.eq(rt.first(form), UNQUOTE) \
else False
def set_recent_vars(self, val):
if rt.eq(val, STAR_1.deref()):
return
STAR_3.set_root(STAR_2.deref())
STAR_2.set_root(STAR_1.deref())
STAR_1.set_root(val)
def set_recent_vars(self, val):
if rt.eq(val, STAR_1.deref()):
return
STAR_3.set_root(STAR_2.deref())
STAR_2.set_root(STAR_1.deref())
STAR_1.set_root(val)
def assoc_inode(self, shift, hash_val, key, val, added_leaf):
bit = bitpos(hash_val, shift)
idx = self.index(bit)
if (self._bitmap & bit) != 0:
key_or_null = self._array[2 * idx]
val_or_node = self._array[2 * idx + 1]
if key_or_null is None:
assert isinstance(val_or_node, INode)
n = val_or_node.assoc_inode(shift + 5, hash_val & MASK_32, key,
val, added_leaf)
if n is val_or_node:
return self
return BitmapIndexedNode(
None, self._bitmap,
clone_and_set(self._array, 2 * idx + 1, n))
if rt.eq(key, key_or_null):
if val is val_or_node:
return self
return BitmapIndexedNode(
None, self._bitmap,
clone_and_set(self._array, 2 * idx + 1, val))
added_leaf._val = added_leaf
return BitmapIndexedNode(
None, self._bitmap,
clone_and_set2(
self._array, 2 * idx, None, 2 * idx + 1,
create_node(shift + 5, key_or_null, val_or_node, hash_val,
key, val)))
else:
n = bit_count(self._bitmap)
if n >= 16:
nodes = [None] * 32
jdx = mask(hash_val, shift)
nodes[jdx] = BitmapIndexedNode_EMPTY.assoc_inode(
shift + 5, hash_val, key, val, added_leaf)
j = 0
for i in range(32):
if (self._bitmap >> i) & 1 != 0:
if self._array[j] is None:
nodes[i] = self._array[j + 1]
else:
nodes[i] = BitmapIndexedNode_EMPTY.assoc_inode(
shift + 5, rt.hash(self._array[j]),
self._array[j], self._array[j + 1], added_leaf)
j += 2
return ArrayNode(None, n + 1, nodes)
else:
new_array = [None] * (2 * (n + 1))
list_copy(self._array, 0, new_array, 0, 2 * idx)
new_array[2 * idx] = key
added_leaf._val = added_leaf
new_array[2 * idx + 1] = val
list_copy(self._array, 2 * idx, new_array, 2 * (idx + 1),
2 * (n - idx))
return BitmapIndexedNode(None, self._bitmap | bit, new_array)
