TonBERRY/micropython
3
0
Fork 0
Code Pull Requests Activity

py: Cast mp_obj_t to concrete types explicitly.

Browse Source 
mp_obj_t internal representation doesn't have to be a pointer to object,
it can be anything.

There's also a support for back-conversion in the form of MP_OBJ_UNCAST.
This is kind of optimization/status quo preserver to minimize patching the
existing code and avoid doing potentially expensive MP_OBJ_CAST over and
over. But then one may imagine implementations where MP_OBJ_UNCAST is very
expensive. But such implementations are unlikely interesting in practice.
This commit is contained in:
Paul Sokolovsky
2015-03-25 09:25:41 +02:00
parent ec1b1cf834
commit 3d598256df
2 changed files with 57 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
py/obj.h
View File

@@ -89,6 +89,21 @@ typedef struct _mp_obj_base_t mp_obj_base_t;
#define MP_OBJ_QSTR_VALUE(o) (((mp_uint_t)(o)) >> 2) #define MP_OBJ_QSTR_VALUE(o) (((mp_uint_t)(o)) >> 2)
#define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)((((mp_uint_t)(qst)) << 2) | 2)) #define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)((((mp_uint_t)(qst)) << 2) | 2))
// Macros to convert between mp_obj_t and concrete object types.
// These are identity operations in MicroPython, but ability to override
// these operations are provided to experiment with other methods of
// object representation and memory management.
// Cast mp_obj_t to object pointer
#ifndef MP_OBJ_CAST
#define MP_OBJ_CAST(o) ((void*)o)
#endif
// Cast object pointer to mp_obj_t
#ifndef MP_OBJ_UNCAST
#define MP_OBJ_UNCAST(p) ((mp_obj_t)p)
#endif
// These macros are used to declare and define constant function objects // These macros are used to declare and define constant function objects
// You can put "static" in front of the definitions to make them local // You can put "static" in front of the definitions to make them local

81
py/objlist.c
View File

@@ -33,7 +33,7 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "py/stackctrl.h" #include "py/stackctrl.h"
STATIC mp_obj_t mp_obj_new_list_iterator(mp_obj_list_t *list, mp_uint_t cur); STATIC mp_obj_t mp_obj_new_list_iterator(mp_obj_t list, mp_uint_t cur);
STATIC mp_obj_list_t *list_new(mp_uint_t n); STATIC mp_obj_list_t *list_new(mp_uint_t n);
STATIC mp_obj_t list_extend(mp_obj_t self_in, mp_obj_t arg_in); STATIC mp_obj_t list_extend(mp_obj_t self_in, mp_obj_t arg_in);
STATIC mp_obj_t list_pop(mp_uint_t n_args, const mp_obj_t *args); STATIC mp_obj_t list_pop(mp_uint_t n_args, const mp_obj_t *args);
@@ -45,7 +45,7 @@ STATIC mp_obj_t list_pop(mp_uint_t n_args, const mp_obj_t *args);
/* list */ /* list */
STATIC void list_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t o_in, mp_print_kind_t kind) { STATIC void list_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t o_in, mp_print_kind_t kind) {
mp_obj_list_t *o = o_in; mp_obj_list_t *o = MP_OBJ_CAST(o_in);
if (!(MICROPY_PY_UJSON && kind == PRINT_JSON)) { if (!(MICROPY_PY_UJSON && kind == PRINT_JSON)) {
kind = PRINT_REPR; kind = PRINT_REPR;
} }
@@ -93,14 +93,14 @@ STATIC bool list_cmp_helper(mp_uint_t op, mp_obj_t self_in, mp_obj_t another_in)
if (!MP_OBJ_IS_TYPE(another_in, &mp_type_list)) { if (!MP_OBJ_IS_TYPE(another_in, &mp_type_list)) {
return false; return false;
} }
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
mp_obj_list_t *another = another_in; mp_obj_list_t *another = MP_OBJ_CAST(another_in);
return mp_seq_cmp_objs(op, self->items, self->len, another->items, another->len); return mp_seq_cmp_objs(op, self->items, self->len, another->items, another->len);
} }
STATIC mp_obj_t list_unary_op(mp_uint_t op, mp_obj_t self_in) { STATIC mp_obj_t list_unary_op(mp_uint_t op, mp_obj_t self_in) {
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
switch (op) { switch (op) {
case MP_UNARY_OP_BOOL: return MP_BOOL(self->len != 0); case MP_UNARY_OP_BOOL: return MP_BOOL(self->len != 0);
case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->len); case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->len);
@@ -109,23 +109,23 @@ STATIC mp_obj_t list_unary_op(mp_uint_t op, mp_obj_t self_in) {
} }
STATIC mp_obj_t list_binary_op(mp_uint_t op, mp_obj_t lhs, mp_obj_t rhs) { STATIC mp_obj_t list_binary_op(mp_uint_t op, mp_obj_t lhs, mp_obj_t rhs) {
mp_obj_list_t *o = lhs; mp_obj_list_t *o = MP_OBJ_CAST(lhs);
switch (op) { switch (op) {
case MP_BINARY_OP_ADD: { case MP_BINARY_OP_ADD: {
if (!MP_OBJ_IS_TYPE(rhs, &mp_type_list)) { if (!MP_OBJ_IS_TYPE(rhs, &mp_type_list)) {
return MP_OBJ_NULL; // op not supported return MP_OBJ_NULL; // op not supported
} }
mp_obj_list_t *p = rhs; mp_obj_list_t *p = MP_OBJ_CAST(rhs);
mp_obj_list_t *s = list_new(o->len + p->len); mp_obj_list_t *s = list_new(o->len + p->len);
mp_seq_cat(s->items, o->items, o->len, p->items, p->len, mp_obj_t); mp_seq_cat(s->items, o->items, o->len, p->items, p->len, mp_obj_t);
return s; return MP_OBJ_UNCAST(s);
} }
case MP_BINARY_OP_INPLACE_ADD: { case MP_BINARY_OP_INPLACE_ADD: {
if (!MP_OBJ_IS_TYPE(rhs, &mp_type_list)) { if (!MP_OBJ_IS_TYPE(rhs, &mp_type_list)) {
return MP_OBJ_NULL; // op not supported return MP_OBJ_NULL; // op not supported
} }
list_extend(lhs, rhs); list_extend(lhs, rhs);
return o; return lhs;
} }
case MP_BINARY_OP_MULTIPLY: { case MP_BINARY_OP_MULTIPLY: {
mp_int_t n; mp_int_t n;
@@ -137,7 +137,7 @@ STATIC mp_obj_t list_binary_op(mp_uint_t op, mp_obj_t lhs, mp_obj_t rhs) {
} }
mp_obj_list_t *s = list_new(o->len * n); mp_obj_list_t *s = list_new(o->len * n);
mp_seq_multiply(o->items, sizeof(*o->items), o->len, n, s->items); mp_seq_multiply(o->items, sizeof(*o->items), o->len, n, s->items);
return s; return MP_OBJ_UNCAST(s);
} }
case MP_BINARY_OP_EQUAL: case MP_BINARY_OP_EQUAL:
case MP_BINARY_OP_LESS: case MP_BINARY_OP_LESS:
@@ -156,7 +156,7 @@ STATIC mp_obj_t list_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
// delete // delete
#if MICROPY_PY_BUILTINS_SLICE #if MICROPY_PY_BUILTINS_SLICE
if (MP_OBJ_IS_TYPE(index, &mp_type_slice)) { if (MP_OBJ_IS_TYPE(index, &mp_type_slice)) {
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
mp_bound_slice_t slice; mp_bound_slice_t slice;
if (!mp_seq_get_fast_slice_indexes(self->len, index, &slice)) { if (!mp_seq_get_fast_slice_indexes(self->len, index, &slice)) {
assert(0); assert(0);
@@ -177,7 +177,7 @@ STATIC mp_obj_t list_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
return mp_const_none; return mp_const_none;
} else if (value == MP_OBJ_SENTINEL) { } else if (value == MP_OBJ_SENTINEL) {
// load // load
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
#if MICROPY_PY_BUILTINS_SLICE #if MICROPY_PY_BUILTINS_SLICE
if (MP_OBJ_IS_TYPE(index, &mp_type_slice)) { if (MP_OBJ_IS_TYPE(index, &mp_type_slice)) {
mp_bound_slice_t slice; mp_bound_slice_t slice;
@@ -186,7 +186,7 @@ STATIC mp_obj_t list_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
} }
mp_obj_list_t *res = list_new(slice.stop - slice.start); mp_obj_list_t *res = list_new(slice.stop - slice.start);
mp_seq_copy(res->items, self->items + slice.start, res->len, mp_obj_t); mp_seq_copy(res->items, self->items + slice.start, res->len, mp_obj_t);
return res; return MP_OBJ_UNCAST(res);
} }
#endif #endif
mp_uint_t index_val = mp_get_index(self->base.type, self->len, index, false); mp_uint_t index_val = mp_get_index(self->base.type, self->len, index, false);
@@ -194,9 +194,9 @@ STATIC mp_obj_t list_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
} else { } else {
#if MICROPY_PY_BUILTINS_SLICE #if MICROPY_PY_BUILTINS_SLICE
if (MP_OBJ_IS_TYPE(index, &mp_type_slice)) { if (MP_OBJ_IS_TYPE(index, &mp_type_slice)) {
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
assert(MP_OBJ_IS_TYPE(value, &mp_type_list)); assert(MP_OBJ_IS_TYPE(value, &mp_type_list));
mp_obj_list_t *slice = value; mp_obj_list_t *slice = MP_OBJ_CAST(value);
mp_bound_slice_t slice_out; mp_bound_slice_t slice_out;
if (!mp_seq_get_fast_slice_indexes(self->len, index, &slice_out)) { if (!mp_seq_get_fast_slice_indexes(self->len, index, &slice_out)) {
assert(0); assert(0);
@@ -234,7 +234,7 @@ STATIC mp_obj_t list_getiter(mp_obj_t o_in) {
mp_obj_t mp_obj_list_append(mp_obj_t self_in, mp_obj_t arg) { mp_obj_t mp_obj_list_append(mp_obj_t self_in, mp_obj_t arg) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
if (self->len >= self->alloc) { if (self->len >= self->alloc) {
self->items = m_renew(mp_obj_t, self->items, self->alloc, self->alloc * 2); self->items = m_renew(mp_obj_t, self->items, self->alloc, self->alloc * 2);
self->alloc *= 2; self->alloc *= 2;
@@ -247,8 +247,8 @@ mp_obj_t mp_obj_list_append(mp_obj_t self_in, mp_obj_t arg) {
STATIC mp_obj_t list_extend(mp_obj_t self_in, mp_obj_t arg_in) { STATIC mp_obj_t list_extend(mp_obj_t self_in, mp_obj_t arg_in) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
if (MP_OBJ_IS_TYPE(arg_in, &mp_type_list)) { if (MP_OBJ_IS_TYPE(arg_in, &mp_type_list)) {
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
mp_obj_list_t *arg = arg_in; mp_obj_list_t *arg = MP_OBJ_CAST(arg_in);
if (self->len + arg->len > self->alloc) { if (self->len + arg->len > self->alloc) {
// TODO: use alloc policy for "4" // TODO: use alloc policy for "4"
@@ -268,7 +268,7 @@ STATIC mp_obj_t list_extend(mp_obj_t self_in, mp_obj_t arg_in) {
STATIC mp_obj_t list_pop(mp_uint_t n_args, const mp_obj_t *args) { STATIC mp_obj_t list_pop(mp_uint_t n_args, const mp_obj_t *args) {
assert(1 <= n_args && n_args <= 2); assert(1 <= n_args && n_args <= 2);
assert(MP_OBJ_IS_TYPE(args[0], &mp_type_list)); assert(MP_OBJ_IS_TYPE(args[0], &mp_type_list));
mp_obj_list_t *self = args[0]; mp_obj_list_t *self = MP_OBJ_CAST(args[0]);
if (self->len == 0) { if (self->len == 0) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_IndexError, "pop from empty list")); nlr_raise(mp_obj_new_exception_msg(&mp_type_IndexError, "pop from empty list"));
} }
@@ -324,8 +324,8 @@ mp_obj_t mp_obj_list_sort(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)]; mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args); mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
mp_obj_list_t *self = pos_args[0]; assert(MP_OBJ_IS_TYPE(pos_args[0], &mp_type_list));
assert(MP_OBJ_IS_TYPE(self, &mp_type_list)); mp_obj_list_t *self = MP_OBJ_CAST(pos_args[0]);
if (self->len > 1) { if (self->len > 1) {
mp_quicksort(self->items, self->items + self->len - 1, mp_quicksort(self->items, self->items + self->len - 1,
@@ -338,7 +338,7 @@ mp_obj_t mp_obj_list_sort(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *
STATIC mp_obj_t list_clear(mp_obj_t self_in) { STATIC mp_obj_t list_clear(mp_obj_t self_in) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
self->len = 0; self->len = 0;
self->items = m_renew(mp_obj_t, self->items, self->alloc, LIST_MIN_ALLOC); self->items = m_renew(mp_obj_t, self->items, self->alloc, LIST_MIN_ALLOC);
self->alloc = LIST_MIN_ALLOC; self->alloc = LIST_MIN_ALLOC;
@@ -348,26 +348,26 @@ STATIC mp_obj_t list_clear(mp_obj_t self_in) {
STATIC mp_obj_t list_copy(mp_obj_t self_in) { STATIC mp_obj_t list_copy(mp_obj_t self_in) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
return mp_obj_new_list(self->len, self->items); return mp_obj_new_list(self->len, self->items);
} }
STATIC mp_obj_t list_count(mp_obj_t self_in, mp_obj_t value) { STATIC mp_obj_t list_count(mp_obj_t self_in, mp_obj_t value) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
return mp_seq_count_obj(self->items, self->len, value); return mp_seq_count_obj(self->items, self->len, value);
} }
STATIC mp_obj_t list_index(mp_uint_t n_args, const mp_obj_t *args) { STATIC mp_obj_t list_index(mp_uint_t n_args, const mp_obj_t *args) {
assert(2 <= n_args && n_args <= 4); assert(2 <= n_args && n_args <= 4);
assert(MP_OBJ_IS_TYPE(args[0], &mp_type_list)); assert(MP_OBJ_IS_TYPE(args[0], &mp_type_list));
mp_obj_list_t *self = args[0]; mp_obj_list_t *self = MP_OBJ_CAST(args[0]);
return mp_seq_index_obj(self->items, self->len, n_args, args); return mp_seq_index_obj(self->items, self->len, n_args, args);
} }
STATIC mp_obj_t list_insert(mp_obj_t self_in, mp_obj_t idx, mp_obj_t obj) { STATIC mp_obj_t list_insert(mp_obj_t self_in, mp_obj_t idx, mp_obj_t obj) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
// insert has its own strange index logic // insert has its own strange index logic
mp_int_t index = MP_OBJ_SMALL_INT_VALUE(idx); mp_int_t index = MP_OBJ_SMALL_INT_VALUE(idx);
if (index < 0) { if (index < 0) {
@@ -401,7 +401,7 @@ mp_obj_t mp_obj_list_remove(mp_obj_t self_in, mp_obj_t value) {
STATIC mp_obj_t list_reverse(mp_obj_t self_in) { STATIC mp_obj_t list_reverse(mp_obj_t self_in) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
mp_int_t len = self->len; mp_int_t len = self->len;
for (mp_int_t i = 0; i < len/2; i++) { for (mp_int_t i = 0; i < len/2; i++) {
@@ -462,7 +462,8 @@ void mp_obj_list_init(mp_obj_list_t *o, mp_uint_t n) {
} }
STATIC mp_obj_list_t *list_new(mp_uint_t n) { STATIC mp_obj_list_t *list_new(mp_uint_t n) {
mp_obj_list_t *o = m_new_obj(mp_obj_list_t); mp_obj_t o_in = m_new_obj(mp_obj_list_t);
mp_obj_list_t *o = MP_OBJ_CAST(o_in);
mp_obj_list_init(o, n); mp_obj_list_init(o, n);
return o; return o;
} }
@@ -474,11 +475,11 @@ mp_obj_t mp_obj_new_list(mp_uint_t n, mp_obj_t *items) {
o->items[i] = items[i]; o->items[i] = items[i];
} }
} }
return o; return MP_OBJ_UNCAST(o);
} }
void mp_obj_list_get(mp_obj_t self_in, mp_uint_t *len, mp_obj_t **items) { void mp_obj_list_get(mp_obj_t self_in, mp_uint_t *len, mp_obj_t **items) {
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
*len = self->len; *len = self->len;
*items = self->items; *items = self->items;
} }
@@ -486,12 +487,12 @@ void mp_obj_list_get(mp_obj_t self_in, mp_uint_t *len, mp_obj_t **items) {
void mp_obj_list_set_len(mp_obj_t self_in, mp_uint_t len) { void mp_obj_list_set_len(mp_obj_t self_in, mp_uint_t len) {
// trust that the caller knows what it's doing // trust that the caller knows what it's doing
// TODO realloc if len got much smaller than alloc // TODO realloc if len got much smaller than alloc
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
self->len = len; self->len = len;
} }
void mp_obj_list_store(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) { void mp_obj_list_store(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
mp_obj_list_t *self = self_in; mp_obj_list_t *self = MP_OBJ_CAST(self_in);
mp_uint_t i = mp_get_index(self->base.type, self->len, index, false); mp_uint_t i = mp_get_index(self->base.type, self->len, index, false);
self->items[i] = value; self->items[i] = value;
} }
@@ -501,14 +502,15 @@ void mp_obj_list_store(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
typedef struct _mp_obj_list_it_t { typedef struct _mp_obj_list_it_t {
mp_obj_base_t base; mp_obj_base_t base;
mp_obj_list_t *list; mp_obj_t list;
mp_uint_t cur; mp_uint_t cur;
} mp_obj_list_it_t; } mp_obj_list_it_t;
STATIC mp_obj_t list_it_iternext(mp_obj_t self_in) { STATIC mp_obj_t list_it_iternext(mp_obj_t self_in) {
mp_obj_list_it_t *self = self_in; mp_obj_list_it_t *self = MP_OBJ_CAST(self_in);
if (self->cur < self->list->len) { mp_obj_list_t *list = MP_OBJ_CAST(self->list);
mp_obj_t o_out = self->list->items[self->cur]; if (self->cur < list->len) {
mp_obj_t o_out = list->items[self->cur];
self->cur += 1; self->cur += 1;
return o_out; return o_out;
} else { } else {
@@ -523,10 +525,11 @@ STATIC const mp_obj_type_t mp_type_list_it = {
.iternext = list_it_iternext, .iternext = list_it_iternext,
}; };
mp_obj_t mp_obj_new_list_iterator(mp_obj_list_t *list, mp_uint_t cur) { mp_obj_t mp_obj_new_list_iterator(mp_obj_t list, mp_uint_t cur) {
mp_obj_list_it_t *o = m_new_obj(mp_obj_list_it_t); mp_obj_t o_out = m_new_obj(mp_obj_list_it_t);
mp_obj_list_it_t *o = MP_OBJ_CAST(o_out);
o->base.type = &mp_type_list_it; o->base.type = &mp_type_list_it;
o->list = list; o->list = list;
o->cur = cur; o->cur = cur;
return o; return o_out;
} }