def codegen(context, builder, sig, args):
fnty = ir.FunctionType(
ll_status,
[ll_dict_type, ll_hash, ll_ssize_t],
)
[d, hk, ix] = args
[td, thk, tix] = sig.args
fn = builder.module.get_or_insert_function(fnty,
name='numba_dict_delitem')
dp = _container_get_data(context, builder, td, d)
status = builder.call(fn, [dp, hk, ix])
return status
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 codegen(context, builder, sig, args):
[tl, tindex] = sig.args
[l, index] = args
fnty = ir.FunctionType(
ll_voidptr_type,
[ll_list_type],
)
fname = 'numba_list_base_ptr'
fn = builder.module.get_or_insert_function(fnty, fname)
fn.attributes.add('alwaysinline')
fn.attributes.add('nounwind')
fn.attributes.add('readonly')
lp = _container_get_data(context, builder, tl, l)
base_ptr = builder.call(
fn,
[
lp,
],
)
llty = context.get_data_type(tl.item_type)
casted_base_ptr = builder.bitcast(base_ptr, llty.as_pointer())
item_ptr = cgutils.gep(builder, casted_base_ptr, index)
if is_none:
out = builder.load(item_ptr)
else:
out = context.make_optional_none(builder, tl.item_type)
pout = cgutils.alloca_once_value(builder, out)
dm_item = context.data_model_manager[tl.item_type]
item = dm_item.load_from_data_pointer(builder, item_ptr)
if not borrowed:
context.nrt.incref(builder, tl.item_type, item)
if is_none:
loaded = item
else:
loaded = context.make_optional_value(
builder, tl.item_type, item)
builder.store(loaded, pout)
out = builder.load(pout)
return context.make_tuple(builder, resty, [ll_status(0), 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_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_getitem')
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_status,
[ll_list_type, ll_ssize_t, ll_ssize_t, ll_ssize_t],
)
[l, start, stop, step] = args
[tl, tstart, tstop, tstep] = sig.args
fn = builder.module.get_or_insert_function(
fnty, name='numba_list_delete_slice')
lp = _container_get_data(context, builder, tl, l)
status = builder.call(
fn,
[
lp,
start,
stop,
step,
],
)
return status
def codegen(context, builder, sig, args):
[tl] = sig.args
[l] = args
fnty = ir.FunctionType(
ll_ssize_t,
[ll_list_type],
)
fname = 'numba_list_size_address'
fn = builder.module.get_or_insert_function(fnty, name=fname)
fn.attributes.add('alwaysinline')
fn.attributes.add('readonly')
fn.attributes.add('nounwind')
lp = _container_get_data(context, builder, tl, l)
len_addr = builder.call(
fn,
[
lp,
],
)
ptr = builder.inttoptr(len_addr, cgutils.intp_t.as_pointer())
return builder.load(ptr)
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(),)
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])