From 0090c714ba94a10b21d8a09756d7d6f7354ac3f9 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Thu, 26 Mar 2015 12:28:31 +0200 Subject: [PATCH] objdict: Cast mp_obj_t to concrete types explicitly. Continuation of refactoring applied previously to objlist. --- py/objdict.c | 109 +++++++++++++++++++++++++++------------------------ 1 file changed, 58 insertions(+), 51 deletions(-) diff --git a/py/objdict.c b/py/objdict.c index 09a5b32122..3e255ec883 100644 --- a/py/objdict.c +++ b/py/objdict.c @@ -56,7 +56,7 @@ STATIC mp_map_elem_t *dict_iter_next(mp_obj_dict_t *dict, mp_uint_t *cur) { } 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 void dict_print(void (*print)(void *env, const char *fmt, ...), void *env } 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_unary_op(mp_uint_t op, mp_obj_t self_in) { } 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 @@ STATIC mp_obj_t dict_binary_op(mp_uint_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) { } 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 @@ STATIC mp_obj_t dict_binary_op(mp_uint_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) { // 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, "")); @@ -166,7 +167,7 @@ STATIC mp_obj_t dict_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) { 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, "")); @@ -185,13 +186,13 @@ STATIC mp_obj_t dict_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) { 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 @@ STATIC const mp_obj_type_t mp_type_dict_it = { .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_getiter(mp_obj_t o_in) { 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_DEFINE_CONST_FUN_OBJ_1(dict_clear_obj, dict_clear); 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 @@ STATIC mp_obj_t dict_fromkeys(mp_uint_t n_args, const mp_obj_t *args) { 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 @@ STATIC mp_obj_t dict_fromkeys(mp_uint_t n_args, const mp_obj_t *args) { 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_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(dict_setdefault_obj, 2, 3, dict_setde 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_DEFINE_CONST_FUN_OBJ_1(dict_popitem_obj, dict_popitem); 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 @@ STATIC mp_obj_t dict_update(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw 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 @@ STATIC char *mp_dict_view_names[] = {"dict_items", "dict_keys", "dict_values"}; 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 const mp_obj_type_t dict_view_it_type = { 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 void dict_view_print(void (*print)(void *env, const char *fmt, ...), void 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 @@ STATIC const mp_obj_type_t dict_view_type = { .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 @@ void mp_obj_dict_init(mp_obj_dict_t *dict, mp_uint_t n_args) { } 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; }