github
/
micropython
mirror of https://github.com/micropython/micropython.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

objdict: Cast mp_obj_t to concrete types explicitly. 

Continuation of refactoring applied previously to objlist.
pull/1164/merge
Paul Sokolovsky 10 years ago
parent
2d717ad97a
commit
0090c714ba
1 changed files with 58 additions and 51 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 109
      py/objdict.c

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;
}

Write Preview
Loading…
Cancel
Save