objdict: Cast mp_obj_t to concrete types explicitly.
Continuation of refactoring applied previously to objlist.
diff --git a/py/objdict.c b/py/objdict.c
index 09a5b32..3e255ec 100644
--- a/py/objdict.c
+++ b/py/objdict.c
@@ -56,7 +56,7 @@
}
STATIC void dict_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
- mp_obj_dict_t *self = self_in;
+ mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
bool first = true;
if (!(MICROPY_PY_UJSON && kind == PRINT_JSON)) {
kind = PRINT_REPR;
@@ -83,24 +83,25 @@
}
STATIC mp_obj_t dict_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
- mp_obj_dict_t *dict = mp_obj_new_dict(0);
- dict->base.type = type_in;
+ mp_obj_t dict_out = mp_obj_new_dict(0);
+ mp_obj_dict_t *dict = MP_OBJ_CAST(dict_out);
+ dict->base.type = MP_OBJ_CAST(type_in);
#if MICROPY_PY_COLLECTIONS_ORDEREDDICT
- if (type_in == &mp_type_ordereddict) {
+ if (MP_OBJ_CAST(type_in) == &mp_type_ordereddict) {
dict->map.is_ordered = 1;
}
#endif
if (n_args > 0 || n_kw > 0) {
- mp_obj_t args2[2] = {dict, args[0]}; // args[0] is always valid, even if it's not a positional arg
+ mp_obj_t args2[2] = {dict_out, args[0]}; // args[0] is always valid, even if it's not a positional arg
mp_map_t kwargs;
mp_map_init_fixed_table(&kwargs, n_kw, args + n_args);
dict_update(n_args + 1, args2, &kwargs); // dict_update will check that n_args + 1 == 1 or 2
}
- return dict;
+ return dict_out;
}
STATIC mp_obj_t dict_unary_op(mp_uint_t op, mp_obj_t self_in) {
- mp_obj_dict_t *self = self_in;
+ mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
switch (op) {
case MP_UNARY_OP_BOOL: return MP_BOOL(self->map.used != 0);
case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->map.used);
@@ -109,7 +110,7 @@
}
STATIC mp_obj_t dict_binary_op(mp_uint_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
- mp_obj_dict_t *o = lhs_in;
+ mp_obj_dict_t *o = MP_OBJ_CAST(lhs_in);
switch (op) {
case MP_BINARY_OP_IN: {
mp_map_elem_t *elem = mp_map_lookup(&o->map, rhs_in, MP_MAP_LOOKUP);
@@ -123,7 +124,7 @@
} else
#endif
if (MP_OBJ_IS_TYPE(rhs_in, &mp_type_dict)) {
- mp_obj_dict_t *rhs = rhs_in;
+ mp_obj_dict_t *rhs = MP_OBJ_CAST(rhs_in);
if (o->map.used != rhs->map.used) {
return mp_const_false;
}
@@ -150,7 +151,7 @@
// TODO: Make sure this is inlined in dict_subscr() below.
mp_obj_t mp_obj_dict_get(mp_obj_t self_in, mp_obj_t index) {
- mp_obj_dict_t *self = self_in;
+ mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
mp_map_elem_t *elem = mp_map_lookup(&self->map, index, MP_MAP_LOOKUP);
if (elem == NULL) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_KeyError, "<value>"));
@@ -166,7 +167,7 @@
return mp_const_none;
} else if (value == MP_OBJ_SENTINEL) {
// load
- mp_obj_dict_t *self = self_in;
+ mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
mp_map_elem_t *elem = mp_map_lookup(&self->map, index, MP_MAP_LOOKUP);
if (elem == NULL) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_KeyError, "<value>"));
@@ -185,13 +186,13 @@
typedef struct _mp_obj_dict_it_t {
mp_obj_base_t base;
- mp_obj_dict_t *dict;
+ mp_obj_t dict;
mp_uint_t cur;
} mp_obj_dict_it_t;
STATIC mp_obj_t dict_it_iternext(mp_obj_t self_in) {
- mp_obj_dict_it_t *self = self_in;
- mp_map_elem_t *next = dict_iter_next(self->dict, &self->cur);
+ mp_obj_dict_it_t *self = MP_OBJ_CAST(self_in);
+ mp_map_elem_t *next = dict_iter_next(MP_OBJ_CAST(self->dict), &self->cur);
if (next == NULL) {
return MP_OBJ_STOP_ITERATION;
@@ -207,12 +208,13 @@
.iternext = dict_it_iternext,
};
-STATIC mp_obj_t dict_getiter(mp_obj_t o_in) {
- mp_obj_dict_it_t *o = m_new_obj(mp_obj_dict_it_t);
+STATIC mp_obj_t dict_getiter(mp_obj_t self_in) {
+ mp_obj_t o_out = m_new_obj(mp_obj_dict_it_t);
+ mp_obj_dict_it_t *o = MP_OBJ_CAST(o_out);
o->base.type = &mp_type_dict_it;
- o->dict = o_in;
+ o->dict = self_in;
o->cur = 0;
- return o;
+ return o_out;
}
/******************************************************************************/
@@ -220,7 +222,7 @@
STATIC mp_obj_t dict_clear(mp_obj_t self_in) {
assert(MP_OBJ_IS_DICT_TYPE(self_in));
- mp_obj_dict_t *self = self_in;
+ mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
mp_map_clear(&self->map);
@@ -230,15 +232,16 @@
STATIC mp_obj_t dict_copy(mp_obj_t self_in) {
assert(MP_OBJ_IS_DICT_TYPE(self_in));
- mp_obj_dict_t *self = self_in;
- mp_obj_dict_t *other = mp_obj_new_dict(self->map.alloc);
+ mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
+ mp_obj_t other_out = mp_obj_new_dict(self->map.alloc);
+ mp_obj_dict_t *other = MP_OBJ_CAST(other_out);
other->base.type = self->base.type;
other->map.used = self->map.used;
other->map.all_keys_are_qstrs = self->map.all_keys_are_qstrs;
other->map.is_fixed = 0;
other->map.is_ordered = self->map.is_ordered;
memcpy(other->map.table, self->map.table, self->map.alloc * sizeof(mp_map_elem_t));
- return other;
+ return other_out;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(dict_copy_obj, dict_copy);
@@ -249,7 +252,7 @@
mp_obj_t len = mp_obj_len_maybe(iter);
mp_obj_t value = mp_const_none;
mp_obj_t next = NULL;
- mp_obj_dict_t *self = NULL;
+ mp_obj_t self_out;
if (n_args > 2) {
value = args[2];
@@ -257,16 +260,17 @@
if (len == MP_OBJ_NULL) {
/* object's type doesn't have a __len__ slot */
- self = mp_obj_new_dict(0);
+ self_out = mp_obj_new_dict(0);
} else {
- self = mp_obj_new_dict(MP_OBJ_SMALL_INT_VALUE(len));
+ self_out = mp_obj_new_dict(MP_OBJ_SMALL_INT_VALUE(len));
}
+ mp_obj_dict_t *self = MP_OBJ_CAST(self_out);
while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
mp_map_lookup(&self->map, next, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
}
- return self;
+ return self_out;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(dict_fromkeys_fun_obj, 2, 3, dict_fromkeys);
STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(dict_fromkeys_obj, (const mp_obj_t)&dict_fromkeys_fun_obj);
@@ -333,7 +337,7 @@
STATIC mp_obj_t dict_popitem(mp_obj_t self_in) {
assert(MP_OBJ_IS_DICT_TYPE(self_in));
- mp_obj_dict_t *self = self_in;
+ mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
mp_uint_t cur = 0;
mp_map_elem_t *next = dict_iter_next(self, &cur);
if (next == NULL) {
@@ -351,7 +355,7 @@
STATIC mp_obj_t dict_update(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
assert(MP_OBJ_IS_DICT_TYPE(args[0]));
- mp_obj_dict_t *self = args[0];
+ mp_obj_dict_t *self = MP_OBJ_CAST(args[0]);
mp_arg_check_num(n_args, kwargs->used, 1, 2, true);
@@ -360,7 +364,7 @@
if (MP_OBJ_IS_DICT_TYPE(args[1])) {
// update from other dictionary (make sure other is not self)
- if (args[1] != self) {
+ if (args[1] != args[0]) {
mp_uint_t cur = 0;
mp_map_elem_t *elem = NULL;
while ((elem = dict_iter_next((mp_obj_dict_t*)args[1], &cur)) != NULL) {
@@ -418,20 +422,20 @@
typedef struct _mp_obj_dict_view_it_t {
mp_obj_base_t base;
mp_dict_view_kind_t kind;
- mp_obj_dict_t *dict;
+ mp_obj_t dict;
mp_uint_t cur;
} mp_obj_dict_view_it_t;
typedef struct _mp_obj_dict_view_t {
mp_obj_base_t base;
- mp_obj_dict_t *dict;
+ mp_obj_t dict;
mp_dict_view_kind_t kind;
} mp_obj_dict_view_t;
STATIC mp_obj_t dict_view_it_iternext(mp_obj_t self_in) {
assert(MP_OBJ_IS_TYPE(self_in, &dict_view_it_type));
- mp_obj_dict_view_it_t *self = self_in;
- mp_map_elem_t *next = dict_iter_next(self->dict, &self->cur);
+ mp_obj_dict_view_it_t *self = MP_OBJ_CAST(self_in);
+ mp_map_elem_t *next = dict_iter_next(MP_OBJ_CAST(self->dict), &self->cur);
if (next == NULL) {
return MP_OBJ_STOP_ITERATION;
@@ -459,24 +463,25 @@
STATIC mp_obj_t dict_view_getiter(mp_obj_t view_in) {
assert(MP_OBJ_IS_TYPE(view_in, &dict_view_type));
- mp_obj_dict_view_t *view = view_in;
- mp_obj_dict_view_it_t *o = m_new_obj(mp_obj_dict_view_it_t);
+ mp_obj_dict_view_t *view = MP_OBJ_CAST(view_in);
+ mp_obj_t o_out = m_new_obj(mp_obj_dict_view_it_t);
+ mp_obj_dict_view_it_t *o = MP_OBJ_CAST(o_out);
o->base.type = &dict_view_it_type;
o->kind = view->kind;
o->dict = view->dict;
o->cur = 0;
- return o;
+ return o_out;
}
STATIC void dict_view_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
(void)kind;
assert(MP_OBJ_IS_TYPE(self_in, &dict_view_type));
- mp_obj_dict_view_t *self = self_in;
+ mp_obj_dict_view_t *self = MP_OBJ_CAST(self_in);
bool first = true;
print(env, mp_dict_view_names[self->kind]);
print(env, "([");
- mp_obj_t *self_iter = dict_view_getiter(self);
- mp_obj_t *next = NULL;
+ mp_obj_t self_iter = dict_view_getiter(self_in);
+ mp_obj_t next = MP_OBJ_NULL;
while ((next = dict_view_it_iternext(self_iter)) != MP_OBJ_STOP_ITERATION) {
if (!first) {
print(env, ", ");
@@ -489,7 +494,7 @@
STATIC mp_obj_t dict_view_binary_op(mp_uint_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
// only supported for the 'keys' kind until sets and dicts are refactored
- mp_obj_dict_view_t *o = lhs_in;
+ mp_obj_dict_view_t *o = MP_OBJ_CAST(lhs_in);
if (o->kind != MP_DICT_VIEW_KEYS) {
return MP_OBJ_NULL; // op not supported
}
@@ -507,18 +512,18 @@
.getiter = dict_view_getiter,
};
-STATIC mp_obj_t mp_obj_new_dict_view(mp_obj_dict_t *dict, mp_dict_view_kind_t kind) {
- mp_obj_dict_view_t *o = m_new_obj(mp_obj_dict_view_t);
+STATIC mp_obj_t mp_obj_new_dict_view(mp_obj_t dict, mp_dict_view_kind_t kind) {
+ mp_obj_t o_out = m_new_obj(mp_obj_dict_view_t);
+ mp_obj_dict_view_t *o = MP_OBJ_CAST(o_out);
o->base.type = &dict_view_type;
o->dict = dict;
o->kind = kind;
- return o;
+ return o_out;
}
STATIC mp_obj_t dict_view(mp_obj_t self_in, mp_dict_view_kind_t kind) {
assert(MP_OBJ_IS_DICT_TYPE(self_in));
- mp_obj_dict_t *self = self_in;
- return mp_obj_new_dict_view(self, kind);
+ return mp_obj_new_dict_view(self_in, kind);
}
STATIC mp_obj_t dict_items(mp_obj_t self_in) {
@@ -593,31 +598,33 @@
}
mp_obj_t mp_obj_new_dict(mp_uint_t n_args) {
- mp_obj_dict_t *o = m_new_obj(mp_obj_dict_t);
+ mp_obj_t o_out = m_new_obj(mp_obj_dict_t);
+ mp_obj_dict_t *o = MP_OBJ_CAST(o_out);
mp_obj_dict_init(o, n_args);
- return o;
+ return o_out;
}
mp_uint_t mp_obj_dict_len(mp_obj_t self_in) {
- return ((mp_obj_dict_t *)self_in)->map.used;
+ mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
+ return self->map.used;
}
mp_obj_t mp_obj_dict_store(mp_obj_t self_in, mp_obj_t key, mp_obj_t value) {
assert(MP_OBJ_IS_DICT_TYPE(self_in));
- mp_obj_dict_t *self = self_in;
+ mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
mp_map_lookup(&self->map, key, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
return self_in;
}
mp_obj_t mp_obj_dict_delete(mp_obj_t self_in, mp_obj_t key) {
assert(MP_OBJ_IS_DICT_TYPE(self_in));
- mp_obj_dict_t *self = self_in;
+ mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
dict_get_helper(&self->map, key, MP_OBJ_NULL, MP_MAP_LOOKUP_REMOVE_IF_FOUND);
return self_in;
}
mp_map_t *mp_obj_dict_get_map(mp_obj_t self_in) {
assert(MP_OBJ_IS_DICT_TYPE(self_in));
- mp_obj_dict_t *self = self_in;
+ mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
return &self->map;
}