Lephenixnoir/PythonExtra
1
0
Fork 2
Code Issues 9 Pull requests 3 Projects Releases 2 Wiki Activity

objdict: Cast mp_obj_t to concrete types explicitly.

Browse source 
Continuation of refactoring applied previously to objlist.
This commit is contained in:
Paul Sokolovsky 2015-03-26 12:28:31 +02:00
parent 2d717ad97a
commit 0090c714ba
1 changed files with 58 additions and 51 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

109
py/objdict.c
View file

@ -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, "<value>"));
@ -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, "<value>"));
@ -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;
}