py: Wrap all obj-ptr conversions in MP_OBJ_TO_PTR/MP_OBJ_FROM_PTR.

This allows the mp_obj_t type to be configured to something other than a
pointer-sized primitive type.

This patch also includes additional changes to allow the code to compile
when sizeof(mp_uint_t) != sizeof(void*), such as using size_t instead of
mp_uint_t, and various casts.

1 files changed, 34 insertions, 36 deletions

diff --git a/py/objlist.c b/py/objlist.c
index 4dd6db27a0..a4bec9e320 100644
--- a/py/objlist.c
+++ b/py/objlist.c
@@ -45,7 +45,7 @@ STATIC mp_obj_t list_pop(mp_uint_t n_args, const mp_obj_t *args);
 /* list                                                                       */
 
 STATIC void list_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t kind) {
-    mp_obj_list_t *o = MP_OBJ_CAST(o_in);
+    mp_obj_list_t *o = MP_OBJ_TO_PTR(o_in);
     if (!(MICROPY_PY_UJSON && kind == PRINT_JSON)) {
         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)) {
         return false;
     }
-    mp_obj_list_t *self = MP_OBJ_CAST(self_in);
-    mp_obj_list_t *another = MP_OBJ_CAST(another_in);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_obj_list_t *another = MP_OBJ_TO_PTR(another_in);
 
     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) {
-    mp_obj_list_t *self = MP_OBJ_CAST(self_in);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
     switch (op) {
         case MP_UNARY_OP_BOOL: return mp_obj_new_bool(self->len != 0);
         case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->len);
@@ -109,16 +109,16 @@ 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) {
-    mp_obj_list_t *o = MP_OBJ_CAST(lhs);
+    mp_obj_list_t *o = MP_OBJ_TO_PTR(lhs);
     switch (op) {
         case MP_BINARY_OP_ADD: {
             if (!MP_OBJ_IS_TYPE(rhs, &mp_type_list)) {
                 return MP_OBJ_NULL; // op not supported
             }
-            mp_obj_list_t *p = MP_OBJ_CAST(rhs);
+            mp_obj_list_t *p = MP_OBJ_TO_PTR(rhs);
             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);
-            return MP_OBJ_UNCAST(s);
+            return MP_OBJ_FROM_PTR(s);
         }
         case MP_BINARY_OP_INPLACE_ADD: {
             list_extend(lhs, rhs);
@@ -134,7 +134,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_seq_multiply(o->items, sizeof(*o->items), o->len, n, s->items);
-            return MP_OBJ_UNCAST(s);
+            return MP_OBJ_FROM_PTR(s);
         }
         case MP_BINARY_OP_EQUAL:
         case MP_BINARY_OP_LESS:
@@ -153,7 +153,7 @@ STATIC mp_obj_t list_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
         // delete
 #if MICROPY_PY_BUILTINS_SLICE
         if (MP_OBJ_IS_TYPE(index, &mp_type_slice)) {
-            mp_obj_list_t *self = MP_OBJ_CAST(self_in);
+            mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
             mp_bound_slice_t slice;
             if (!mp_seq_get_fast_slice_indexes(self->len, index, &slice)) {
                 assert(0);
@@ -174,7 +174,7 @@ STATIC mp_obj_t list_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_list_t *self = MP_OBJ_CAST(self_in);
+        mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
 #if MICROPY_PY_BUILTINS_SLICE
         if (MP_OBJ_IS_TYPE(index, &mp_type_slice)) {
             mp_bound_slice_t slice;
@@ -183,7 +183,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_seq_copy(res->items, self->items + slice.start, res->len, mp_obj_t);
-            return MP_OBJ_UNCAST(res);
+            return MP_OBJ_FROM_PTR(res);
         }
 #endif
         mp_uint_t index_val = mp_get_index(self->base.type, self->len, index, false);
@@ -191,9 +191,9 @@ STATIC mp_obj_t list_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
     } else {
 #if MICROPY_PY_BUILTINS_SLICE
         if (MP_OBJ_IS_TYPE(index, &mp_type_slice)) {
-            mp_obj_list_t *self = MP_OBJ_CAST(self_in);
+            mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
             assert(MP_OBJ_IS_TYPE(value, &mp_type_list));
-            mp_obj_list_t *slice = MP_OBJ_CAST(value);
+            mp_obj_list_t *slice = MP_OBJ_TO_PTR(value);
             mp_bound_slice_t slice_out;
             if (!mp_seq_get_fast_slice_indexes(self->len, index, &slice_out)) {
                 assert(0);
@@ -231,7 +231,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) {
     assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
-    mp_obj_list_t *self = MP_OBJ_CAST(self_in);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
     if (self->len >= self->alloc) {
         self->items = m_renew(mp_obj_t, self->items, self->alloc, self->alloc * 2);
         self->alloc *= 2;
@@ -244,8 +244,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) {
     assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
     if (MP_OBJ_IS_TYPE(arg_in, &mp_type_list)) {
-        mp_obj_list_t *self = MP_OBJ_CAST(self_in);
-        mp_obj_list_t *arg = MP_OBJ_CAST(arg_in);
+        mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
+        mp_obj_list_t *arg = MP_OBJ_TO_PTR(arg_in);
 
         if (self->len + arg->len > self->alloc) {
             // TODO: use alloc policy for "4"
@@ -265,7 +265,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) {
     assert(1 <= n_args && n_args <= 2);
     assert(MP_OBJ_IS_TYPE(args[0], &mp_type_list));
-    mp_obj_list_t *self = MP_OBJ_CAST(args[0]);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(args[0]);
     if (self->len == 0) {
         nlr_raise(mp_obj_new_exception_msg(&mp_type_IndexError, "pop from empty list"));
     }
@@ -322,7 +322,7 @@ mp_obj_t mp_obj_list_sort(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
     assert(MP_OBJ_IS_TYPE(pos_args[0], &mp_type_list));
-    mp_obj_list_t *self = MP_OBJ_CAST(pos_args[0]);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(pos_args[0]);
 
     if (self->len > 1) {
         mp_quicksort(self->items, self->items + self->len - 1,
@@ -335,7 +335,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) {
     assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
-    mp_obj_list_t *self = MP_OBJ_CAST(self_in);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
     self->len = 0;
     self->items = m_renew(mp_obj_t, self->items, self->alloc, LIST_MIN_ALLOC);
     self->alloc = LIST_MIN_ALLOC;
@@ -345,26 +345,26 @@ STATIC mp_obj_t list_clear(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));
-    mp_obj_list_t *self = MP_OBJ_CAST(self_in);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
     return mp_obj_new_list(self->len, self->items);
 }
 
 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));
-    mp_obj_list_t *self = MP_OBJ_CAST(self_in);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
     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) {
     assert(2 <= n_args && n_args <= 4);
     assert(MP_OBJ_IS_TYPE(args[0], &mp_type_list));
-    mp_obj_list_t *self = MP_OBJ_CAST(args[0]);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(args[0]);
     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) {
     assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
-    mp_obj_list_t *self = MP_OBJ_CAST(self_in);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
     // insert has its own strange index logic
     mp_int_t index = MP_OBJ_SMALL_INT_VALUE(idx);
     if (index < 0) {
@@ -398,7 +398,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) {
     assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
-    mp_obj_list_t *self = MP_OBJ_CAST(self_in);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
 
     mp_int_t len = self->len;
     for (mp_int_t i = 0; i < len/2; i++) {
@@ -447,7 +447,7 @@ const mp_obj_type_t mp_type_list = {
     .binary_op = list_binary_op,
     .subscr = list_subscr,
     .getiter = list_getiter,
-    .locals_dict = (mp_obj_t)&list_locals_dict,
+    .locals_dict = (mp_obj_dict_t*)&list_locals_dict,
 };
 
 void mp_obj_list_init(mp_obj_list_t *o, mp_uint_t n) {
@@ -459,8 +459,7 @@ 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) {
-    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_t *o = m_new_obj(mp_obj_list_t);
     mp_obj_list_init(o, n);
     return o;
 }
@@ -472,11 +471,11 @@ mp_obj_t mp_obj_new_list(mp_uint_t n, mp_obj_t *items) {
             o->items[i] = items[i];
         }
     }
-    return MP_OBJ_UNCAST(o);
+    return MP_OBJ_FROM_PTR(o);
 }
 
 void mp_obj_list_get(mp_obj_t self_in, mp_uint_t *len, mp_obj_t **items) {
-    mp_obj_list_t *self = MP_OBJ_CAST(self_in);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
     *len = self->len;
     *items = self->items;
 }
@@ -484,12 +483,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) {
     // trust that the caller knows what it's doing
     // TODO realloc if len got much smaller than alloc
-    mp_obj_list_t *self = MP_OBJ_CAST(self_in);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
     self->len = len;
 }
 
 void mp_obj_list_store(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
-    mp_obj_list_t *self = MP_OBJ_CAST(self_in);
+    mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
     mp_uint_t i = mp_get_index(self->base.type, self->len, index, false);
     self->items[i] = value;
 }
@@ -504,8 +503,8 @@ typedef struct _mp_obj_list_it_t {
 } mp_obj_list_it_t;
 
 STATIC mp_obj_t list_it_iternext(mp_obj_t self_in) {
-    mp_obj_list_it_t *self = MP_OBJ_CAST(self_in);
-    mp_obj_list_t *list = MP_OBJ_CAST(self->list);
+    mp_obj_list_it_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_obj_list_t *list = MP_OBJ_TO_PTR(self->list);
     if (self->cur < list->len) {
         mp_obj_t o_out = list->items[self->cur];
         self->cur += 1;
@@ -523,10 +522,9 @@ STATIC const mp_obj_type_t mp_type_list_it = {
 };
 
 mp_obj_t mp_obj_new_list_iterator(mp_obj_t list, mp_uint_t cur) {
-    mp_obj_t o_out = m_new_obj(mp_obj_list_it_t);
-    mp_obj_list_it_t *o = MP_OBJ_CAST(o_out);
+    mp_obj_list_it_t *o = m_new_obj(mp_obj_list_it_t);
     o->base.type = &mp_type_list_it;
     o->list = list;
     o->cur = cur;
-    return o_out;
+    return MP_OBJ_FROM_PTR(o);
 }