def codegen(context, builder, sig, args):
fnty = ir.FunctionType(
ll_status,
[ll_dict_type, ll_bytes, ll_hash, ll_bytes, ll_bytes],
)
[d, key, hashval, val] = args
[td, tkey, thashval, tval] = sig.args
fn = builder.module.get_or_insert_function(fnty,
name='numba_dict_insert')
dm_key = context.data_model_manager[tkey]
dm_val = context.data_model_manager[tval]
data_key = dm_key.as_data(builder, key)
data_val = dm_val.as_data(builder, val)
ptr_key = cgutils.alloca_once_value(builder, data_key)
ptr_val = cgutils.alloca_once_value(builder, data_val)
# TODO: the ptr_oldval is not used. needed for refct
ptr_oldval = cgutils.alloca_once(builder, data_val.type)
dp = _container_get_data(context, builder, td, d)
status = builder.call(
fn,
[
dp,
_as_bytes(builder, ptr_key),
hashval,
_as_bytes(builder, ptr_val),
_as_bytes(builder, ptr_oldval),
],
)
return status
def impl_dict_getiter(context, builder, sig, args):
"""Implement iter(Dict). Semantically equivalent to dict.keys()
"""
[td] = sig.args
[d] = args
iterablety = types.DictKeysIterableType(td)
it = context.make_helper(builder, iterablety.iterator_type)
fnty = ir.FunctionType(
ir.VoidType(),
[ll_dictiter_type, ll_dict_type],
)
fn = builder.module.get_or_insert_function(fnty, name='numba_dict_iter')
proto = ctypes.CFUNCTYPE(ctypes.c_size_t)
dictiter_sizeof = proto(_helperlib.c_helpers['dict_iter_sizeof'])
state_type = ir.ArrayType(ir.IntType(8), dictiter_sizeof())
pstate = cgutils.alloca_once(builder, state_type, zfill=True)
it.state = _as_bytes(builder, pstate)
it.parent = d
dp = _container_get_data(context, builder, iterablety.parent, args[0])
builder.call(fn, [it.state, dp])
return impl_ret_borrowed(
context,
builder,
sig.return_type,
it._getvalue(),
)
def codegen(context, builder, sig, args):
fnty = ir.FunctionType(
ll_status,
[ll_list_type, ll_bytes],
)
[l, item] = args
[tl, titem] = sig.args
fn = builder.module.get_or_insert_function(fnty,
name='numba_list_append')
dm_item = context.data_model_manager[titem]
data_item = dm_item.as_data(builder, item)
ptr_item = cgutils.alloca_once_value(builder, data_item)
lp = _container_get_data(context, builder, tl, l)
status = builder.call(
fn,
[
lp,
_as_bytes(builder, ptr_item),
],
)
return status
def impl_iterable_getiter(context, builder, sig, args):
"""Implement iter() for .keys(), .values(), .items()
"""
iterablety = sig.args[0]
it = context.make_helper(builder, iterablety.iterator_type, args[0])
fnty = ir.FunctionType(
ir.VoidType(),
[ll_dictiter_type, ll_dict_type],
)
fn = cgutils.get_or_insert_function(builder.module, fnty,
'numba_dict_iter')
proto = ctypes.CFUNCTYPE(ctypes.c_size_t)
dictiter_sizeof = proto(_helperlib.c_helpers['dict_iter_sizeof'])
state_type = ir.ArrayType(ir.IntType(8), dictiter_sizeof())
pstate = cgutils.alloca_once(builder, state_type, zfill=True)
it.state = _as_bytes(builder, pstate)
dp = _container_get_data(context, builder, iterablety.parent, it.parent)
builder.call(fn, [it.state, dp])
return impl_ret_borrowed(
context,
builder,
sig.return_type,
it._getvalue(),
)
def codegen_get_voidptr(context, builder, ty_var, var_val):
dm_key = context.data_model_manager[ty_var]
data_val = dm_key.as_data(builder, var_val)
ptr_var = cgutils.alloca_once_value(builder, data_val)
val_as_voidptr = _as_bytes(builder, ptr_var)
return val_as_voidptr
def codegen(context, builder, sig, args):
fnty = ir.FunctionType(ll_status, [ll_list_type, ll_ssize_t, ll_bytes],)
[tl, tindex] = sig.args
[l, index] = args
fn = builder.module.get_or_insert_function(
fnty, name="numba_list_{}".format(op)
)
dm_item = context.data_model_manager[tl.item_type]
ll_item = context.get_data_type(tl.item_type)
ptr_item = cgutils.alloca_once(builder, ll_item)
lp = _container_get_data(context, builder, tl, l)
status = builder.call(fn, [lp, index, _as_bytes(builder, ptr_item),],)
# Load item if output is available
found = builder.icmp_signed(">=", status, status.type(int(ListStatus.LIST_OK)))
out = context.make_optional_none(
builder, tl.item_type if IS_NOT_NONE else types.int64
)
pout = cgutils.alloca_once_value(builder, out)
with builder.if_then(found):
if IS_NOT_NONE:
item = dm_item.load_from_data_pointer(builder, ptr_item)
context.nrt.incref(builder, tl.item_type, item)
loaded = context.make_optional_value(builder, tl.item_type, item)
builder.store(loaded, pout)
out = builder.load(pout)
return context.make_tuple(builder, resty, [status, out])
def codegen(context, builder, sig, args):
fnty = ir.FunctionType(
ll_ssize_t,
[ll_dict_type, ll_bytes, ll_hash, ll_bytes],
)
[td, tkey, thashval] = sig.args
[d, key, hashval] = args
fn = cgutils.get_or_insert_function(builder.module, fnty,
'numba_dict_lookup')
dm_key = context.data_model_manager[tkey]
dm_val = context.data_model_manager[td.value_type]
data_key = dm_key.as_data(builder, key)
ptr_key = cgutils.alloca_once_value(builder, data_key)
cgutils.memset_padding(builder, ptr_key)
ll_val = context.get_data_type(td.value_type)
ptr_val = cgutils.alloca_once(builder, ll_val)
dp = _container_get_data(context, builder, td, d)
ix = builder.call(
fn,
[
dp,
_as_bytes(builder, ptr_key),
hashval,
_as_bytes(builder, ptr_val),
],
)
# Load value if output is available
found = builder.icmp_signed('>', ix, ix.type(int(DKIX.EMPTY)))
out = context.make_optional_none(builder, td.value_type)
pout = cgutils.alloca_once_value(builder, out)
with builder.if_then(found):
val = dm_val.load_from_data_pointer(builder, ptr_val)
context.nrt.incref(builder, td.value_type, val)
loaded = context.make_optional_value(builder, td.value_type, val)
builder.store(loaded, pout)
out = builder.load(pout)
return context.make_tuple(builder, resty, [ix, out])
def codegen(context, builder, sig, args):
fnty = ir.FunctionType(
ll_status,
[ll_dict_type, ll_bytes, ll_bytes],
)
[d] = args
[td] = sig.args
fn = builder.module.get_or_insert_function(fnty,
name='numba_dict_popitem')
dm_key = context.data_model_manager[td.key_type]
dm_val = context.data_model_manager[td.value_type]
ptr_key = cgutils.alloca_once(builder, dm_key.get_data_type())
ptr_val = cgutils.alloca_once(builder, dm_val.get_data_type())
dp = _container_get_data(context, builder, td, d)
status = builder.call(
fn,
[
dp,
_as_bytes(builder, ptr_key),
_as_bytes(builder, ptr_val),
],
)
out = context.make_optional_none(builder, keyvalty)
pout = cgutils.alloca_once_value(builder, out)
cond = builder.icmp_signed('==', status, status.type(int(Status.OK)))
with builder.if_then(cond):
key = dm_key.load_from_data_pointer(builder, ptr_key)
val = dm_val.load_from_data_pointer(builder, ptr_val)
keyval = context.make_tuple(builder, keyvalty, [key, val])
optkeyval = context.make_optional_value(builder, keyvalty, keyval)
builder.store(optkeyval, pout)
out = builder.load(pout)
return cgutils.pack_struct(builder, [status, out])
def impl_list_getiter(context, builder, sig, args):
"""Implement iter(List)."""
[tl] = sig.args
[l] = args
iterablety = types.ListTypeIterableType(tl)
it = context.make_helper(builder, iterablety.iterator_type)
fnty = ir.FunctionType(ir.VoidType(), [ll_listiter_type, ll_list_type],)
fn = builder.module.get_or_insert_function(fnty, name="numba_list_iter")
proto = ctypes.CFUNCTYPE(ctypes.c_size_t)
listiter_sizeof = proto(_helperlib.c_helpers["list_iter_sizeof"])
state_type = ir.ArrayType(ir.IntType(8), listiter_sizeof())
pstate = cgutils.alloca_once(builder, state_type, zfill=True)
it.state = _as_bytes(builder, pstate)
it.parent = l
dp = _container_get_data(context, builder, iterablety.parent, args[0])
builder.call(fn, [it.state, dp])
return impl_ret_borrowed(context, builder, sig.return_type, it._getvalue(),)
